如何编写HTTP触发的Firebase云函数实现管理员注册新用户

Got it, let's break down exactly how to build this admin user registration flow using Firebase Cloud Functions and HTTP POST requests. I’ve implemented this exact setup for a few projects, so here’s a step-by-step guide with code examples:

1. Prerequisites #

First, make sure your Firebase project is set up with Cloud Functions:

• Initialize Cloud Functions in your project (run firebase init functions if you haven’t already)
• Install the firebase-admin SDK in the functions directory: npm install firebase-admin

2. Write the Cloud Function (Handle POST Requests) #

This function will:

• Reject non-POST requests
• Verify the requester is an authenticated admin
• Create a new user from the POST body data
• Return appropriate success/error responses

Here’s the code for functions/index.js:

const functions = require("firebase-functions");
const admin = require("firebase-admin");

// Initialize Firebase Admin SDK
admin.initializeApp();

exports.createAdminManagedUser = functions.https.onRequest(async (req, res) => {
  // 1. Ensure we're handling a POST request
  if (req.method !== "POST") {
    return res.status(405).send("Method Not Allowed — only POST requests are accepted");
  }

  // 2. Validate the admin's authentication token
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith("Bearer ")) {
    return res.status(401).send("Unauthorized: No valid authentication token provided");
  }

  const idToken = authHeader.split("Bearer ")[1];
  try {
    // Verify the token and decode its contents
    const decodedToken = await admin.auth().verifyIdToken(idToken);
    
    // Check if the user is marked as an admin (using custom claims)
    // Note: You'll need to set this claim for your admin users first (see note below)
    if (!decodedToken.admin) {
      return res.status(403).send("Forbidden: Only admins can create new users");
    }
  } catch (error) {
    functions.logger.error("Token verification failed:", error);
    return res.status(401).send("Unauthorized: Invalid authentication token");
  }

  // 3. Extract new user data from the POST request body
  const { email, password, displayName, photoURL } = req.body;
  
  // Validate required fields
  if (!email || !password) {
    return res.status(400).send("Bad Request: Email and password are required fields");
  }

  // 4. Create the new user in Firebase Auth
  try {
    const userRecord = await admin.auth().createUser({
      email: email,
      password: password,
      displayName: displayName || null,
      photoURL: photoURL || null,
    });

    // Optional: Set default custom claims for the new user (e.g., mark as regular user)
    await admin.auth().setCustomUserClaims(userRecord.uid, {
      admin: false,
    });

    // Return success response
    return res.status(201).json({
      message: "New user created successfully",
      uid: userRecord.uid,
      email: userRecord.email,
      displayName: userRecord.displayName
    });
  } catch (error) {
    functions.logger.error("Error creating user:", error);
    // Return specific error messages based on Firebase Auth error codes
    let errorMessage = "Failed to create user";
    if (error.code === "auth/email-already-exists") {
      errorMessage = "This email is already registered";
    } else if (error.code === "auth/invalid-email") {
      errorMessage = "Invalid email format";
    } else if (error.code === "auth/weak-password") {
      errorMessage = "Password is too weak (must be at least 6 characters)";
    }
    return res.status(500).send(errorMessage);
  }
});

Key Notes on Admin Validation #

To mark a user as an admin (so they can call this function), you’ll need to set a custom claim for their account. You can do this via:

• A one-time local script
• Another restricted cloud function
• Manually in the Firebase Console (under Authentication > Users > Edit User > Custom Claims)

Example script to set admin claims:

// Run this locally (after initializing admin SDK)
const admin = require("firebase-admin");
admin.initializeApp();

async function setAdminClaim(uid) {
  await admin.auth().setCustomUserClaims(uid, { admin: true });
  console.log(`User ${uid} has been marked as admin`);
}

// Replace with your admin user's UID
setAdminClaim("YOUR_ADMIN_USER_UID");

3. Deploy the Cloud Function #

Run this command from your project root to deploy the function:

firebase deploy --only functions:createAdminManagedUser

After deployment, you’ll get a URL like https://REGION-PROJECT_ID.cloudfunctions.net/createAdminManagedUser — this is the endpoint your frontend will send POST requests to.

4. Frontend: Send POST Request to the Function #

Here’s an example using JavaScript’s fetch API to send the request from your admin dashboard:

// Assuming you have an authenticated admin user in Firebase Auth
async function createNewUser(userData) {
  try {
    // Get the admin user's ID token (required for authentication)
    const adminUser = firebase.auth().currentUser;
    if (!adminUser) {
      throw new Error("Admin user not authenticated");
    }
    const idToken = await adminUser.getIdToken();

    // Send POST request to the cloud function
    const response = await fetch("https://REGION-PROJECT_ID.cloudfunctions.net/createAdminManagedUser", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${idToken}`
      },
      body: JSON.stringify(userData)
    });

    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(errorText);
    }

    const result = await response.json();
    console.log("User created successfully:", result);
    return result;
  } catch (error) {
    console.error("Error creating user:", error);
    alert(`Failed to create user: ${error.message}`);
  }
}

// Usage example
createNewUser({
  email: "newuser@example.com",
  password: "SecurePass123!",
  displayName: "New Admin User"
});

5. Testing Tips #

• Local Testing: Use firebase emulators:start to test the function locally before deploying. The emulator will give you a local URL to send requests to.
• Error Handling: Make sure to handle common errors like duplicate emails, weak passwords, and invalid tokens in both the function and frontend.

内容的提问来源于stack exchange，提问作者dongerpep