Instructivo de autenticación de usuarios finales para Cloud Run

En este instructivo, se muestra cómo crear un servicio de votación, que consiste en lo siguiente:

Un cliente basado en el navegador que realiza las siguientes acciones:
1. Usa Identity Platform para recuperar un token de ID.
2. Permite a los usuarios votar por su animales nacionales favoritos.
3. Agrega ese token de ID a una solicitud al servidor de Cloud Run que procesa el voto.
Un servidor de Cloud Run que realiza las siguientes acciones:
1. Verifica que el usuario final se haya autenticado de forma correcta mediante un token de ID válido.
2. Procesa el voto del usuario final.
3. Con sus propias credenciales, se envía el voto a Cloud SQL para el almacenamiento.
Una base de datos PostgreSQL que almacena los votos.

Para que sea más simple, en este instructivo se usa Google como proveedor: los usuarios deben autenticarse con una Cuenta de Google a fin de adquirir su token de ID. Sin embargo, puedes usar otros proveedores o métodos de autenticación para que los usuarios accedan.

Este servicio minimiza los riesgos de seguridad con Secret Manager a fin de proteger los datos sensibles que se usan para conectarse a la instancia de Cloud SQL. También usa una identidad de servicio con privilegios mínimos para proteger el acceso a la base de datos.

Objetivos

Escribir, compilar e implementar un servicio en Cloud Run que muestre cómo realizar lo siguiente:

Usa Identity Platform para autenticar un usuario final en el backend del servicio de Cloud Run.
Crea una identidad con privilegios mínimos para que el servicio otorgue acceso mínimo a los recursos de Google Cloud.
Usa Secret Manager para manejar datos sensibles cuando conectas el servicio de Cloud Run a una base de datos PostgreSQL.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Enable the Cloud Run, Secret Manager, Cloud SQL, Artifact Registry, and Cloud Build APIs.
Enable the APIs

Roles obligatorios

Si quieres obtener los permisos que necesitas para completar el instructivo, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

Administrador del repositorio de Artifact Registry (roles/artifactregistry.repoAdmin)
Editor de Cloud Build (roles/cloudbuild.builds.editor)
Administrador de Cloud Run (roles/run.admin)
Administrador de Cloud SQL (roles/cloudsql.admin)
Crea cuentas de servicio (roles/iam.serviceAccountCreator)
Administrador de Identity Platform (roles/identityplatform.admin)
Editor de configuración de OAuth (roles/oauthconfig.editor)
Administrador de IAM de proyecto (roles/resourcemanager.projectIamAdmin)
Administrador de Secret Manager (roles/secretmanager.admin)
Usuario de cuenta de servicio (roles/iam.serviceAccountUser)
Consumidor de Service Usage (roles/serviceusage.serviceUsageConsumer)
Administrador de almacenamiento (roles/storage.admin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Configura los valores predeterminados de `gcloud`

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

Configura el proyecto predeterminado:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre del proyecto que creaste para este instructivo.
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.

Ubicaciones de Cloud Run

Cloud Run es regional, lo que significa que la infraestructura que ejecuta los servicios se ubica en una región específica, y Google la administra para que esté disponible de manera redundante en todas las zonas de esa región.

El cumplimiento de los requisitos de latencia, disponibilidad o durabilidad es el factor principal para seleccionar la región en la que se ejecutan los servicios de Cloud Run. Por lo general, puedes seleccionar la región más cercana a los usuarios, pero debes considerar la ubicación de los otros productos de Google Cloud que usa el servicio de Cloud Run. Si usas productos de Google Cloud en varias ubicaciones, la latencia y el costo del servicio pueden verse afectados.

Cloud Run está disponible en las siguientes regiones:

Sujetas a los Precios del nivel 1

asia-east1 (Taiwán)
asia-northeast1 (Tokio)
asia-northeast2 (Osaka)
europe-north1 (Finlandia) Bajo nivel de CO₂
europe-southwest1 (Madrid) Bajo nivel de CO₂
europe-west1 (Bélgica) Bajo nivel de CO₂
europe-west4 (Países Bajos) Bajo nivel de CO₂
europe-west8 (Milán)
europe-west9 (París) Bajo nivel de CO₂
me-west1 (Tel Aviv)
us-central1 (Iowa) Bajo nivel de CO₂
us-east1 (Carolina del Sur)
us-east4 (Virginia del Norte)
us-east5 (Columbus)
us-south1 (Dallas) Bajo nivel de CO₂
us-west1 (Oregón) Bajo nivel de CO₂

Sujetas a los Precios del nivel 2

africa-south1 (Johannesburgo)
asia-east2 (Hong Kong)
asia-northeast3 (Seúl, Corea del Sur)
asia-southeast1 (Singapur)
asia-southeast2 (Yakarta)
asia-south1 (Bombay, India)
asia-south2 Delhi (India)
australia-southeast1 (Sídney)
australia-southeast2 (Melbourne)
europe-central2 (Varsovia, Polonia)
europe-west10 (Berlín) Bajo nivel de CO₂
europe-west12 (Turín)
europe-west2 (Londres, Reino Unido) Bajo nivel de CO₂
europe-west3 (Fráncfort, Alemania) Bajo nivel de CO₂
europe-west6 (Zúrich, Suiza) Bajo nivel de CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) Bajo nivel de CO₂
northamerica-northeast2 (Toronto) Bajo nivel de CO₂
southamerica-east1 (São Paulo, Brasil) Bajo nivel de CO₂
southamerica-west1 (Santiago, Chile) Bajo nivel de CO₂
us-west2 (Los Ángeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Si ya creaste un servicio de Cloud Run, puedes ver la región en el panel de Cloud Run en la consola de Google Cloud.

Recupera la muestra de código

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

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.

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

Diagrama de arquitectura — En el diagrama, se muestra un acceso de usuario final a través de una ventana de diálogo de Acceso con Google que proporciona el Identity Platform y, luego, se lo redirecciona a Cloud Run con la identidad del usuario.

Un usuario final realiza la primera solicitud al servidor de Cloud Run.
El cliente se carga en el navegador.
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ó.
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.
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.

Node.js

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);
  }
};

Python

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

Java

/** 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.

Node.js

/**
 * 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,
  });
};

Python

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

Java

Usa la integración del activador de PostgreSQL Spring Cloud Google Cloud para interactuar con tus bases de datos de PostgreSQL en Cloud SQL mediante las bibliotecas de JDBC de Spring. Establece tu configuración de Cloud SQL para MySQL para que configure automáticamente un bean DataSource, que, junto con JDBC de Spring, proporciona un bean de objeto JdbcTemplate que permite operaciones como consultar y modificar una base de datos.

# 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.

Node.js

// 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}`
    );
  }
}

Python

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)

Java

/** 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.

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

Ir a la página Marketplace de Identity Platform
Haz clic en Habilitar Identity Platform.
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 Externa.
4. Haz clic en Crear.
5. En el cuadro de diálogo Información de la app, haz lo siguiente:
  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 deseas usar para el contacto del desarrollador.
6. Haz clic en Guardar y continuar.
7. En el diálogo Alcances, haz clic en Guardar y continuar.
8. En el cuadro de 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.
Crea y obtén tu ID de cliente de OAuth y tu secreto:
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.
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 del SDK web, ingresa los valores 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”:

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

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"
}

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

Crea una cuenta de servicio para el servidor mediante Console o la CLI:
```
gcloud iam service-accounts create idp-sql-identity
```

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

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

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

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.
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
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.

Nota: Las variables de entorno se resuelven en el momento del inicio de la instancia, por lo que si usas este método, Google te recomienda fijar el secreto en una versión específica en lugar de usar la versión más reciente.

Retoques finales

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

Para editar el proveedor de Google, haz clic en el ícono de lápiz en la página Proveedores de identidad.
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)'
```
Ir a la página APIs y servicios > Credenciales
1. Haz clic en el ícono de lápiz que se encuentra junto a tu ID de cliente de OAuth para editarlo y debajo del 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:

Dirige tu navegador a la URL proporcionada en el paso de implementación anterior.
Haz clic en el botón Acceder con Google y completa el flujo de autenticación.
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.

Limpia

Si creaste un proyecto nuevo para este instructivo, bórralo. Si usaste un proyecto existente y deseas conservarlo sin los cambios que se agregaron en este instructivo, borra los recursos creados para el instructivo.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

En la consola de Google Cloud, ve a la página Administrar recursos.
Ir a Administrar recursos
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra los recursos del instructivo

Usa este comando para borrar el servicio de Cloud Run que implementaste en este instructivo:
```
gcloud run services delete SERVICE-NAME
```
En el ejemplo anterior, SERVICE-NAME es el nombre del servicio que elegiste.

También puedes borrar los servicios de Cloud Run desde la consola de Google Cloud.
Quita la configuración de región predeterminada de gcloud que agregaste durante la configuración en el instructivo:
```
 gcloud config unset run/region
```
Quita la configuración del proyecto:
```
 gcloud config unset project
```
Borra otros recursos de Google Cloud que creaste en este instructivo:

¿Qué sigue?

Obtén más información en Conéctate desde Cloud Run a Cloud SQL.
Obtén más información sobre los métodos de acceso y la administración de usuarios con Identity Platform.
Revisa otras formas de autenticar desarrolladores, servicios y usuarios de los servicios implementados en Cloud Run.
Analiza otras demostraciones, instructivos y muestras de Cloud Run.

Instructivo de autenticación de usuarios finales para Cloud Run

Objetivos

Costos

Antes de comenzar

Roles obligatorios

Configura los valores predeterminados de gcloud

Ubicaciones de Cloud Run

Sujetas a los Precios del nivel 1

Sujetas a los Precios del nivel 2

Recupera la muestra de código

Node.js

Python

Java

Node.js

Python

Java

Visualiza la arquitectura

Comprende el código central

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

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

Node.js

Python

Java

Conecta el servidor a Cloud SQL

Node.js

Python

Java

Controla la configuración sensible con Secret Manager

Node.js

Python

Java

Configura Identity Platform

Implementa el servicio

Node.js

Python

Java

Node.js

Python

Java

Retoques finales

Prueba

Limpia

Borra el proyecto

Borra los recursos del instructivo

¿Qué sigue?

Configura los valores predeterminados de `gcloud`