Instructivo de autenticación de usuarios finales para Cloud Run

Configura los valores predeterminados de gcloud

A fin de configurar gcloud con los valores predeterminados para el servicio de Cloud Run, sigue estos pasos:

1. Configura el proyecto predeterminado:

   gcloud config set project PROJECT_ID

   Reemplaza PROJECT_ID por el nombre del proyecto que creaste para este instructivo.

2. Configura gcloud en la región que elegiste:

   gcloud config set run/region REGION

   Reemplaza REGION por la región de Cloud Run compatible que prefieras.

Recupera la muestra de código

A fin de recuperar la muestra de código para su uso, haz lo siguiente:

1. Clona el repositorio de la app de muestra en tu máquina local:

   Node.js

   git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

   De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.

   Python

   git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

   De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.

   Java

   git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

   De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.

2. Ve al directorio que contiene el código de muestra de Cloud Run:

   Node.js

   cd nodejs-docs-samples/run/idp-sql/

   Python

   cd python-docs-samples/run/idp-sql/

   Java

   cd java-docs-samples/run/idp-sql/

Visualiza la arquitectura

1. Un usuario final realiza la primera solicitud al servidor de Cloud Run.

2. El cliente se carga en el navegador.

3. El usuario proporciona credenciales de acceso a través del diálogo de Acceso con Google desde Identity Platform. Una alerta le da la bienvenida al usuario que accedió.

4. El control se redirecciona al servidor. El usuario final vota por el cliente, que recupera un token de ID de Identity Platform y lo agrega al encabezado de la solicitud de votación.

5. Cuando el servidor recibe la solicitud, verifica el token de ID de Identity Platform y confirma que el usuario final está autenticado de forma adecuada. Luego, el servidor envía el voto a Cloud SQL con sus propias credenciales.

Comprende el código central

La muestra se implementa como cliente y servidor, como se describe a continuación.

Integración en Identity Platform: código del cliente

En esta muestra, se usan los SDK de Firebase a fin de integrarse a Identity Platform para acceder y administrar usuarios. Para conectarse a Identity Platform, el JavaScript del cliente contiene la referencia a las credenciales del proyecto como un objeto de configuración e importa los SDK de Firebase JavaScript necesarios:

const config = {
  apiKey: 'API_KEY',
  authDomain: 'PROJECT_ID.firebaseapp.com',
};

<!-- Firebase App (the core Firebase SDK) is always required and must be listed first-->
<script src="https://www.gstatic.com/firebasejs/7.18/firebase-app.js"></script>
<!-- Add Firebase Auth service-->
<script src="https://www.gstatic.com/firebasejs/7.18/firebase-auth.js"></script>

El SDK de Firebase JavaScript controla el flujo de acceso. Para ello, solicita al usuario final que acceda a su Cuenta de Google a través de una ventana emergente. Luego, los redirecciona al servicio.

function signIn() {
  const provider = new firebase.auth.GoogleAuthProvider();
  provider.addScope('https://www.googleapis.com/auth/userinfo.email');
  firebase
    .auth()
    .signInWithPopup(provider)
    .then(result => {
      // Returns the signed in user along with the provider's credential
      console.log(`${result.user.displayName} logged in.`);
      window.alert(`Welcome ${result.user.displayName}!`);
    })
    .catch(err => {
      console.log(`Error during sign in: ${err.message}`);
      window.alert('Sign in failed. Retry or check your browser logs.');
    });
}

Cuando un usuario accede de forma correcta, el cliente usa los métodos de Firebase para crear un token de ID. El cliente agrega el token de ID al encabezado Authorization de su solicitud al servidor.

async function vote(team) {
  if (firebase.auth().currentUser) {
    // Retrieve JWT to identify the user to the Identity Platform service.
    // Returns the current token if it has not expired. Otherwise, this will
    // refresh the token and return a new one.
    try {
      const token = await firebase.auth().currentUser.getIdToken();
      const response = await fetch('/', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          Authorization: `Bearer ${token}`,
        },
        body: 'team=' + team, // send application data (vote)
      });
      if (response.ok) {
        const text = await response.text();
        window.alert(text);
        window.location.reload();
      }
    } catch (err) {
      console.log(`Error when submitting vote: ${err}`);
      window.alert('Something went wrong... Please try again!');
    }
  } else {
    window.alert('User not signed in.');
  }
}

Integración en Identity Platform: código del servidor

El servidor usa el SDK de Firebase Admin para verificar el token de ID de usuario que se envió desde el cliente. Si el token de ID proporcionado tiene el formato correcto, no está vencido y tiene la firma adecuada, el método muestra el token de ID decodificado. El servidor extrae uid de Identity Platform para ese usuario.

const firebase = require('firebase-admin');
// Initialize Firebase Admin SDK
firebase.initializeApp();

// Extract and verify Id Token from header
const authenticateJWT = (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (authHeader) {
    const token = authHeader.split(' ')[1];
    // If the provided ID token has the correct format, is not expired, and is
    // properly signed, the method returns the decoded ID token
    firebase
      .auth()
      .verifyIdToken(token)
      .then(decodedToken => {
        const uid = decodedToken.uid;
        req.uid = uid;
        next();
      })
      .catch(err => {
        req.logger.error(`Error with authentication: ${err}`);
        return res.sendStatus(403);
      });
  } else {
    return res.sendStatus(401);
  }
};

def jwt_authenticated(func: Callable[..., int]) -> Callable[..., int]:
    """Use the Firebase Admin SDK to parse Authorization header to verify the
    user ID token.

    The server extracts the Identity Platform uid for that user.
    """

    @wraps(func)
    def decorated_function(*args: a, **kwargs: a) -> a:
        header = request.headers.get("Authorization", None)
        if header:
            token = header.split(" ")[1]
            try:
                decoded_token = firebase_admin.auth.verify_id_token(token)
            except Exception as e:
                logger.exception(e)
                return Response(status=403, response=f"Error with authentication: {e}")
        else:
            return Response(status=401)

        request.uid = decoded_token["uid"]
        return func(*args, **kwargs)

    return decorated_function

/** Extract and verify Id Token from header */
private String authenticateJwt(Map<String, String> headers) {
  String authHeader =
      (headers.get("authorization") != null)
          ? headers.get("authorization")
          : headers.get("Authorization");
  if (authHeader != null) {
    String idToken = authHeader.split(" ")[1];
    // If the provided ID token has the correct format, is not expired, and is
    // properly signed, the method returns the decoded ID token
    try {
      FirebaseToken decodedToken = FirebaseAuth.getInstance().verifyIdToken(idToken);
      String uid = decodedToken.getUid();
      return uid;
    } catch (FirebaseAuthException e) {
      logger.error("Error with authentication: " + e.toString());
      throw new ResponseStatusException(HttpStatus.FORBIDDEN, "", e);
    }
  } else {
    logger.error("Error no authorization header");
    throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
  }
}

Conecta el servidor a Cloud SQL

El servidor se conecta al socket de dominio Unix de la instancia de Cloud SQL con el siguiente formato: /cloudsql/CLOUD_SQL_CONNECTION_NAME.

/**
 * Connect to the Cloud SQL instance through UNIX Sockets
 *
 * @param {object} credConfig The Cloud SQL connection configuration from Secret Manager
 * @returns {object} Knex's PostgreSQL client
 */
const connectWithUnixSockets = async credConfig => {
  const dbSocketPath = process.env.DB_SOCKET_PATH || '/cloudsql';
  // Establish a connection to the database
  return Knex({
    client: 'pg',
    connection: {
      user: credConfig.DB_USER, // e.g. 'my-user'
      password: credConfig.DB_PASSWORD, // e.g. 'my-user-password'
      database: credConfig.DB_NAME, // e.g. 'my-database'
      host: `${dbSocketPath}/${credConfig.CLOUD_SQL_CONNECTION_NAME}`,
    },
    ...config,
  });
};

def init_unix_connection_engine(
    db_config: dict[str, int]
) -> sqlalchemy.engine.base.Engine:
    """Initializes a Unix socket connection pool for a Cloud SQL instance of PostgreSQL.

    Args:
        db_config: a dictionary with connection pool config

    Returns:
        A SQLAlchemy Engine instance.
    """
    creds = credentials.get_cred_config()
    db_user = creds["DB_USER"]
    db_pass = creds["DB_PASSWORD"]
    db_name = creds["DB_NAME"]
    db_socket_dir = creds.get("DB_SOCKET_DIR", "/cloudsql")
    cloud_sql_connection_name = creds["CLOUD_SQL_CONNECTION_NAME"]

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # postgres+pg8000://<db_user>:<db_pass>@/<db_name>
        #                         ?unix_sock=<socket_path>/<cloud_sql_instance_name>/.s.PGSQL.5432
        sqlalchemy.engine.url.URL.create(
            drivername="postgresql+pg8000",
            username=db_user,  # e.g. "my-database-user"
            password=db_pass,  # e.g. "my-database-password"
            database=db_name,  # e.g. "my-database-name"
            query={
                "unix_sock": f"{db_socket_dir}/{cloud_sql_connection_name}/.s.PGSQL.5432"
                # e.g. "/cloudsql", "<PROJECT-NAME>:<INSTANCE-REGION>:<INSTANCE-NAME>"
            },
        ),
        **db_config,
    )
    pool.dialect.description_encoding = None
    logger.info("Database engine initialized from unix connection")

    return pool

# Uncomment and add env vars for local development
# spring.datasource.username=${DB_USER}
# spring.datasource.password=${DB_PASSWORD}
# spring.cloud.gcp.sql.database-name=${DB_NAME}
# spring.cloud.gcp.sql.instance-connection-name=${CLOUD_SQL_CONNECTION_NAME}  

private final JdbcTemplate jdbcTemplate;

public VoteController(JdbcTemplate jdbcTemplate) {
  this.jdbcTemplate = jdbcTemplate;
}

Controla la configuración sensible con Secret Manager

Secret Manager proporciona almacenamiento centralizado y seguro de datos sensibles, como la configuración de Cloud SQL. El server inserta las credenciales de Cloud SQL desde Secret Manager en el entorno de ejecución a través de una variable de entorno. Obtén más información sobre cómo usar secretos con Cloud Run.

// CLOUD_SQL_CREDENTIALS_SECRET is the resource ID of the secret, passed in by environment variable.
// Format: projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION
const {CLOUD_SQL_CREDENTIALS_SECRET} = process.env;
if (CLOUD_SQL_CREDENTIALS_SECRET) {
  try {
    // Parse the secret that has been added as a JSON string
    // to retrieve database credentials
    return JSON.parse(CLOUD_SQL_CREDENTIALS_SECRET.toString('utf8'));
  } catch (err) {
    throw Error(
      `Unable to parse secret from Secret Manager. Make sure that the secret is JSON formatted: ${err}`
    );
  }
}

def get_cred_config() -> dict[str, str]:
    """Retrieve Cloud SQL credentials stored in Secret Manager
    or default to environment variables.

    Returns:
        A dictionary with Cloud SQL credential values
    """
    secret = os.environ.get("CLOUD_SQL_CREDENTIALS_SECRET")
    if secret:
        return json.loads(secret)

/** Retrieve config from Secret Manager */
public static HashMap<String, Object> getConfig() {
  String secret = System.getenv("CLOUD_SQL_CREDENTIALS_SECRET");
  if (secret == null) {
    throw new IllegalStateException("\"CLOUD_SQL_CREDENTIALS_SECRET\" is required.");
  }
  try {
    HashMap<String, Object> config = new Gson().fromJson(secret, HashMap.class);
    return config;
  } catch (JsonSyntaxException e) {
    logger.error(
        "Unable to parse secret from Secret Manager. Make sure that it is JSON formatted: "
            + e);
    throw new RuntimeException(
        "Unable to parse secret from Secret Manager. Make sure that it is JSON formatted.");
  }
}

Configura Identity Platform

Identity Platform requiere una configuración manual en la consola de Google Cloud.

1. Ve a la página Marketplace de Identity Platform en la consola de Google Cloud.

   Ir a la página Marketplace de Identity Platform

2. Haz clic en Habilitar Identity Platform.

3. Crea tu pantalla de consentimiento de OAuth:

   1. En una ventana nueva, ve a la página APIs y servicios > Credenciales.

      Ir a la página APIs y servicios > Credenciales

   2. Selecciona la página Pantalla de consentimiento de OAuth.

   3. Para realizar pruebas, selecciona Externo.

   4. Haz clic en Crear.

   5. En el diálogo Información de la app,

      1. Proporciona el nombre de la aplicación.
      2. Selecciona uno de los correos electrónicos de asistencia al usuario que se muestran.
      3. Ingresa el correo electrónico que quieres usar para el contacto del desarrollador.

   6. Haz clic en Guardar y continuar.

   7. En el diálogo Permisos, haz clic en Guardar y continuar.

   8. En el diálogo Usuarios de prueba, haz clic en Guardar y continuar.

   9. En el diálogo Resumen, haz clic en Volver al panel.

   10. En Estado de publicación, haz clic en Publicar app.

   11. Haz clic en Confirmar.

4. Crea y obtén tu ID y secreto de cliente de OAuth:

   1. Ir a la página APIs y servicios > Credenciales

   2. En la parte superior de la página, haz clic en Crear credenciales y selecciona OAuth client ID.

   3. En Tipo de aplicación, selecciona Aplicación web y proporciona el nombre.

   4. Haz clic en Crear.

   5. Toma nota de client_id y client_secret para usarlos más adelante en este procedimiento.

5. Configura Google como proveedor:

   1. Ve a la página Proveedores de identidad en la consola de Cloud.

      Ir a la página Proveedores de identidad

   2. Haz clic en Agregar un proveedor.

   3. Selecciona Google de la lista.

   4. En la configuración de Web SDK Configuration, ingresa los valores de client_id y client_secret de los pasos anteriores.

   5. En Configura tu aplicación, haz clic en Detalles de la configuración.

   6. Copia los valores de apiKey y authDomain en el static/config.js de la muestra para inicializar el SDK de cliente de Identity Platform.

   7. Haz clic en Guardar.

Implementa el servicio

Sigue los pasos que se indican a continuación para completar el aprovisionamiento y la implementación de la infraestructura, o bien automatiza el proceso en Cloud Shell. Para ello, haz clic en “Ejecutar en Google Cloud”:

1. Crea una instancia de Cloud SQL con base de datos PostgreSQL mediante Console o la CLI:

   gcloud sql instances create CLOUD_SQL_INSTANCE_NAME \
       --database-version=POSTGRES_12 \
       --region=CLOUD_SQL_REGION \
       --cpu=2 \
       --memory=7680MB \
       --root-password=DB_PASSWORD

2. Agrega los valores de la credencial de Cloud SQL a postgres-secrets.json:

   Node.js

   {
     "CLOUD_SQL_CONNECTION_NAME": "PROJECT_ID:REGION:INSTANCE",
     "DB_NAME": "postgres",
     "DB_USER": "postgres",
     "DB_PASSWORD": "PASSWORD_SECRET"
   }
   

   Python

   {
     "CLOUD_SQL_CONNECTION_NAME": "PROJECT_ID:REGION:INSTANCE",
     "DB_NAME": "postgres",
     "DB_USER": "postgres",
     "DB_PASSWORD": "PASSWORD_SECRET"
   }
   

   Java

   {
     "spring.cloud.gcp.sql.instance-connection-name": "PROJECT_ID:REGION:INSTANCE",
     "spring.cloud.gcp.sql.database-name": "postgres",
     "spring.datasource.username": "postgres",
     "spring.datasource.password": "PASSWORD_SECRET"
   }

3. Crea un secreto con versión mediante Console o la CLI:

   gcloud secrets create idp-sql-secrets \
       --replication-policy="automatic" \
       --data-file=postgres-secrets.json

4. Crea una cuenta de servicio para el servidor mediante Console o la CLI:

   gcloud iam service-accounts create idp-sql-identity

5. Otorga roles para el acceso de Secret Manager y Cloud SQL mediante Console o la CLI:

   1. Permite que la cuenta de servicio asociada con el servidor acceda al secreto creado:

      gcloud secrets add-iam-policy-binding idp-sql-secrets \
        --member serviceAccount:idp-sql-identity@PROJECT_ID.iam.gserviceaccount.com \
        --role roles/secretmanager.secretAccessor

   2. Permite que la cuenta de servicio asociada con el servidor acceda a Cloud SQL:

      gcloud projects add-iam-policy-binding PROJECT_ID \
        --member serviceAccount:idp-sql-identity@PROJECT_ID.iam.gserviceaccount.com \
        --role roles/cloudsql.client

6. Crea un Artifact Registry:

   gcloud artifacts repositories create REPOSITORY \
       --repository-format docker \
       --location REGION

   • REPOSITORY es el nombre del repositorio. Para la ubicación de cada repositorio en un proyecto, los nombres de los repositorios deben ser únicos.

7. Usa Cloud Build para compilar la imagen de contenedor:

   Node.js

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/idp-sql

   Python

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/idp-sql

   Java

   En esta muestra, se usa Jib para compilar imágenes de Docker mediante herramientas de Java comunes. Jib optimiza las compilaciones de contenedores sin la necesidad de tener un Dockerfile o tener Docker instalado. Obtén más información sobre la compilación de contenedores de Java con Jib.

   1. Usa el auxiliar de credenciales de gcloud para autorizar a Docker a que envíe contenido a tu Artefact Registry.

      gcloud auth configure-docker

   2. Usa el complemento de Maven para Jib para compilar y enviar el contenedor a Artefact Registry.

      mvn compile jib:build -Dimage=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/idp-sql

8. Implementa la imagen de contenedor en Cloud Run mediante Console o la CLI. Ten en cuenta que el servidor se implementa para permitir el acceso no autenticado. Esto es para que el usuario pueda cargar el cliente y comenzar el proceso. El servidor verifica el token de ID que se agregó a la solicitud de votación de forma manual y autentica al usuario final.

   gcloud run deploy idp-sql \
       --image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/idp-sql \
       --allow-unauthenticated \
       --service-account idp-sql-identity@PROJECT_ID.iam.gserviceaccount.com \
       --add-cloudsql-instances PROJECT_ID:REGION:CLOUD_SQL_INSTANCE_NAME \
       --update-secrets CLOUD_SQL_CREDENTIALS_SECRET=idp-sql-secrets:latest

   También toma nota de las marcas, --service-account, --add-cloudsql-instances y --update-secrets, que especifican la identidad del servicio, la conexión de la instancia de Cloud SQL y el nombre del secreto con la versión como entorno, respectivamente.

Retoques finales

Identity Platform requiere que autorices la URL del servicio de Cloud Run como un redireccionamiento permitido después del acceso del usuario:

1. Para editar el proveedor de Google, haz clic en el ícono de lápiz en la página Proveedores de identidad.

2. Haz clic en Agregar un dominio en Dominios autorizados en el panel derecho y, luego, ingresa la URL de servicio de Cloud Run.

   Puedes ubicar la URL del servicio en los registros después de la compilación o implementación, o puedes encontrarla en cualquier momento con el siguiente comando:

   gcloud run services describe idp-sql --format 'value(status.url)'

3. Ir a la página APIs y servicios > Credenciales

   1. Haz clic en el ícono de lápiz junto a tu ID de cliente de OAuth para editarlo y, luego, en el botón Authorized redirect URIs click the Agregar URI.

   2. En el campo, copia y pega la siguiente URL y haz clic en el botón Guardar en la parte inferior de la página.

   https://PROJECT_ID.firebaseapp.com/__/auth/handler

Prueba

Para probar el servicio completo, haz lo siguiente:

1. Dirige tu navegador a la URL proporcionada en el paso de implementación anterior.

2. Haz clic en el botón Acceder con Google y completa el flujo de autenticación.

3. Agrega tu voto.

   Se verá de la siguiente manera:

   

Si eliges seguir desarrollando estos servicios, recuerda que tienen acceso restringido de la administración de identidades y accesos (IAM) al resto de Google Cloud y necesitarán tener funciones de IAM adicionales para acceder a muchos otros servicios.