Tutorial sull'autenticazione dell'utente finale per Cloud Run

Questo tutorial mostra come creare un servizio di voto, costituito da:

Un client basato su browser che:
1. Utilizza Identity Platform per recuperare un token ID.
2. Consente agli utenti di votare per scegliere il loro animale domestico preferito.
3. Aggiunge il token ID a una richiesta al server Cloud Run che elabora il voto.
Un server Cloud Run che:
1. Controlla che l'utente finale abbia eseguito correttamente l'autenticazione fornendo un token ID valido.
2. Elabora il voto dell'utente finale.
3. Utilizzando le proprie credenziali, il voto viene inviato a Cloud SQL per l'archiviazione.
Un database PostgreSQL in cui sono archiviati i voti.

Per semplicità, questo tutorial utilizza Google come provider: gli utenti devono eseguire l'autenticazione utilizzando un Account Google per acquisire il loro token ID. Tuttavia, puoi utilizzare altri provider o metodi di autenticazione per accedere agli utenti.

Questo servizio riduce al minimo i rischi per la sicurezza utilizzando Secret Manager per proteggere i dati sensibili utilizzati per la connessione all'istanza Cloud SQL. Utilizza inoltre un'identità di servizio con privilegio minimo per proteggere l'accesso al database.

Obiettivi

Scrivi, crea ed esegui il deployment di un servizio in Cloud Run che mostra come:

Utilizzare Identity Platform per autenticare un utente finale nel backend del servizio Cloud Run.
Creare un'identità con privilegi minimi per il servizio per concedere un accesso minimo alle risorse Google Cloud.
Utilizza Secret Manager per gestire i dati sensibili durante la connessione del servizio Cloud Run a un database postgreSQL.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Prima di iniziare

Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Cloud Run, Secret Manager, Cloud SQL, Artifact Registry, and Cloud Build .
Abilita le API

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare il tutorial, chiedi all'amministratore di concederti il ruolo IAM Proprietario (roles/owner) per il tuo progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche essere in grado di ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Configurazione delle impostazioni predefinite per `gcloud` in corso...

Per configurare gcloud con i valori predefiniti per il tuo servizio Cloud Run:

Imposta il progetto predefinito:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del progetto che hai creato per questo tutorial.
Configura gcloud per la regione scelta:
```
gcloud config set run/region REGION
```
Sostituisci REGION con un'area geografica Cloud Run supportata a tua scelta.

Località di Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità sono fattori principali per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. In genere, puoi selezionare la regione più vicina ai tuoi utenti, ma ti consigliamo di considerare la località degli altri prodotti Google Cloud utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato di prodotti Google Cloud in più località può influire sulla latenza e sui costi del tuo servizio.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

asia-east1 (Taiwan)
asia-northeast1 (Tokyo)
asia-northeast2 (Osaka)
europe-north1 (Finlandia) Bassi livelli di CO₂
europe-southwest1 (Madrid)
europe-west1 (Belgio) Bassi livelli di CO₂
europe-west4 (Paesi Bassi)
europe-west8 (Milano)
europe-west9 (Parigi) A basse emissioni di CO₂
me-west1 (Tel Aviv)
us-central1 (Iowa) A basse emissioni di CO₂
us-east1 (Carolina del Sud)
us-east4 (Virginia del Nord)
us-east5 (Colombo)
us-south1 (Dallas)
us-west1 (Oregon) Bassi livelli di CO₂

Soggetto ai prezzi di Livello 2

africa-south1 (Johannesburg)
asia-east2 (Hong Kong)
asia-northeast3 (Seul, Corea del Sud)
asia-southeast1 (Singapore)
asia-southeast2 (Giacarta)
asia-south1 (Mumbai, India)
asia-south2 (Delhi, India)
australia-southeast1 (Sydney)
australia-southeast2 (Melbourne)
europe-central2 (Varsavia, Polonia)
europe-west10 (Berlino)
europe-west12 (Torino)
europe-west2 (Londra, Regno Unito) A basse emissioni di CO₂
europe-west3 (Francoforte, Germania) A basse emissioni di CO₂
europe-west6 (Zurigo, Svizzera) A basse emissioni di CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) A basse emissioni di CO₂
northamerica-northeast2 (Toronto) A basse emissioni di CO₂
southamerica-east1 (San Paolo, Brasile) A basse emissioni di CO₂
southamerica-west1 (Santiago, Cile) A basse emissioni di CO₂
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare la regione nella dashboard di Cloud Run nella console Google Cloud.

Recupero dell'esempio di codice

Per recuperare l'esempio di codice da utilizzare:

Clona il repository dell'app di esempio sulla tua macchina locale:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

Passa alla directory che contiene il codice di esempio di 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/

Visualizzare l'architettura

Diagramma dell'architettura — Il diagramma mostra l'accesso di un utente finale tramite un popup di accesso con Google fornito da Identity Platform, per poi essere reindirizzato a Cloud Run con l'identità dell'utente.

Un utente finale invia la prima richiesta al server Cloud Run.
Il client viene caricato nel browser.
L'utente fornisce le credenziali di accesso tramite la finestra popup Accedi con Google da Identity Platform. Un avviso dà il benvenuto all'utente che ha eseguito l'accesso.
Il controllo viene reindirizzato al server. L'utente finale vota utilizzando il client, che recupera un token ID da Identity Platform e lo aggiunge all'intestazione della richiesta di voto.
Quando il server riceve la richiesta, verifica il token ID di Identity Platform, confermando che l'utente finale è correttamente autenticato. Quindi, il server invia il voto a Cloud SQL, utilizzando le proprie credenziali.

Comprensione del codice di base

L'esempio viene implementato come client e server, come descritto di seguito.

Integrazione con Identity Platform: codice lato client

Questo esempio utilizza gli SDK Firebase per l'integrazione con Identity Platform al fine di accedere e gestire gli utenti. Per connettersi a Identity Platform, il codice JavaScript lato client contiene il riferimento alle credenziali del progetto come oggetto di configurazione e importa gli SDK Firebase JavaScript necessari:

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>

L'SDK Firebase JavaScript gestisce il flusso di accesso chiedendo all'utente finale di accedere al proprio Account Google tramite una finestra popup. Quindi li reindirizza al servizio.

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

Quando un utente accede, il client utilizza metodi Firebase per generare un token ID. Il client aggiunge il token ID all'intestazione Authorization della sua richiesta al server.

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

Integrazione con Identity Platform: codice lato server

Il server utilizza l'SDK Firebase Admin per verificare il token ID utente inviato dal client. Se il token ID fornito è nel formato corretto, non è scaduto ed è firmato correttamente, il metodo restituisce il token ID decodificato. Il server estrae Identity Platform uid per l'utente in questione.

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

Connessione del server a Cloud SQL

Il server si connette al socket di dominio Unix dell'istanza Cloud SQL utilizzando il 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

Utilizza l'integrazione del comando iniziale Google Cloud PostgreSQL di Spring Cloud per interagire con i tuoi database PostgreSQL in Google Cloud SQL utilizzando le librerie JDBC di Spring. Imposta la configurazione di Cloud SQL per MySQL in modo da configurare automaticamente un bean DataSource che, in combinazione con Spring JDBC, fornisce un bean di oggetti JdbcTemplate che consente operazioni come l'esecuzione di query e la modifica di un database.

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

Gestione della configurazione sensibile con Secret Manager

Secret Manager fornisce archiviazione centralizzata e sicura di dati sensibili come la configurazione di Cloud SQL. Il server inserisce le credenziali Cloud SQL da Secret Manager in fase di runtime tramite una variabile di ambiente. Scopri di più sull'utilizzo dei secret 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.");
  }
}

Configurazione di Identity Platform

Identity Platform richiede la configurazione manuale nella console Google Cloud.

Vai alla pagina Identity Platform Marketplace nella console Google Cloud.

Vai alla pagina Marketplace di Identity Platform
Fai clic su Abilita Identity Platform.
Crea la tua schermata per il consenso OAuth:
1. In una nuova finestra, vai alla pagina API e servizi > Credenziali
  
  Vai alla pagina API e servizi > Credenziali
2. Fai clic su Configura la schermata per il consenso.
3. A scopo di test, seleziona Esterno.
4. Fai clic su Crea.
5. Nella finestra di dialogo Informazioni sull'app,
  1. Fornisci il nome dell'applicazione.
  2. Seleziona una delle email per l'assistenza utenti visualizzate.
  3. Inserisci l'indirizzo email da utilizzare per il contatto dello sviluppatore.
6. Fai clic su Save and Continue.
7. Nella finestra di dialogo Ambiti e utenti di test, fai clic su Salva e continua.
8. Fai clic su Torna alla dashboard.
9. Nella sezione Stato di pubblicazione, fai clic su Pubblica app.
10. Fai clic su Conferma.
Crea e recupera il tuo ID client e secret OAuth:
1. Vai alla pagina API e servizi > Credenziali
2. Nella parte superiore della pagina, fai clic su Crea credenziali e seleziona OAuth client ID.
3. In Application Type (Tipo di applicazione), seleziona Web Application (Applicazione web) e indica il nome.
4. Prendi nota dei client_id e dei client_secret per utilizzarli in seguito in questa procedura.
Configura Google come provider:
1. Vai alla pagina Provider di identità nella console Cloud.
  
  Vai alla pagina Provider di identità
2. Fai clic su Add A Provider (Aggiungi un provider).
3. Seleziona Google dall'elenco.
4. Nelle impostazioni di configurazione dell'SDK web, inserisci i valori client_id e client_secret dei passaggi precedenti.
5. In Configura la tua applicazione, fai clic su Dettagli di configurazione.
6. Copia i valori apiKey e authDomain nel file static/config.js dell'esempio per inizializzare l'SDK client di Identity Platform.
7. Fai clic su Salva.

Deployment del servizio

Segui i passaggi riportati di seguito per completare il provisioning e il deployment dell'infrastruttura o per automatizzare il processo in Cloud Shell facendo clic su "Esegui su Google Cloud":

Crea un'istanza Cloud SQL con un database postgreSQL utilizzando la console o l'interfaccia a riga di comando:

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

Aggiungi i valori delle tue credenziali 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 secret con controllo delle versioni utilizzando la console o l'interfaccia a riga di comando:

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

Crea un account di servizio per il server utilizzando la console o l'interfaccia a riga di comando:
```
gcloud iam service-accounts create idp-sql-identity
```

Concedi i ruoli per l'accesso a Secret Manager e Cloud SQL utilizzando la console o l'interfaccia a riga di comando:

Consenti all'account di servizio associato al server di accedere al secret creato:

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

Consenti all'account di servizio associato al server di accedere 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 è il nome del repository. Per ogni località del repository in un progetto, i nomi dei repository devono essere univoci.
Crea l'immagine container utilizzando Cloud Build:
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

Questo esempio utilizza Jib per creare immagini Docker con gli strumenti Java comuni. Jib ottimizza le build di container senza bisogno di un Dockerfile o di dover installare Docker. Scopri di più sulla creazione di container Java con Jib.
1. Utilizza l'helper delle credenziali gcloud per autorizzare Docker a eseguire il push al tuo Artifact Registry.
```
gcloud auth configure-docker
```
2. Utilizza il plug-in Maven per Jib per creare il container ed eseguirne il push in Artifact Registry.
```
mvn compile jib:build -Dimage=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/idp-sql
```
Esegui il deployment dell'immagine container in Cloud Run utilizzando la console o l'interfaccia a riga di comando. Tieni presente che il deployment del server è stato eseguito in modo da consentire l'accesso non autenticato. In questo modo, l'utente può caricare il client e iniziare il processo. Il server verifica manualmente il token ID aggiunto alla richiesta di voto, autenticando l'utente finale.
```
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
```
Osserva inoltre i flag --service-account, --add-cloudsql-instances e --update-secrets, che specificano rispettivamente l'identità del servizio, la connessione dell'istanza Cloud SQL e il nome del secret con la versione come variabile di ambiente.

Nota: le variabili di ambiente vengono risolte al momento dell'avvio dell'istanza, quindi se utilizzi questo metodo, Google consiglia di fissare il secret su una determinata versione anziché utilizzare il codice più recente.

Tocchi finali

Identity Platform richiede di autorizzare l'URL del servizio Cloud Run come reindirizzamento consentito dopo l'accesso dell'utente:

Modifica il provider Google facendo clic sull'icona della penna nella pagina Provider di identità.
Fai clic su Aggiungi dominio in Domini autorizzati nel riquadro a destra e inserisci l'URL del servizio Cloud Run.

Puoi individuare l'URL del servizio nei log dopo la build o il deployment oppure puoi trovarlo in qualsiasi momento usando:
```
gcloud run services describe idp-sql --format 'value(status.url)'
```
Vai alla pagina API e servizi > Credenziali
1. Fai clic sull'icona a forma di matita accanto all'ID client OAuth per modificarlo e sotto il pulsante Authorized redirect URIs click the Aggiungi URI.
2. Nel campo, copia e incolla il seguente URL e fai clic sul pulsante Salva in fondo alla pagina.
```
https://PROJECT_ID.firebaseapp.com/__/auth/handler
```

Provalo

Per provare il servizio completo:

Vai nel browser all'URL fornito nel passaggio di deployment riportato sopra.
Fai clic sul pulsante Accedi con Google e segui la procedura di autenticazione.
Aggiungi il tuo voto.

Dovrebbe avere il seguente aspetto:

Se scegli di continuare a sviluppare questi servizi, ricorda che questi hanno un accesso limitato di Identity and Access Management (IAM) al resto di Google Cloud e che dovranno disporre di ruoli IAM aggiuntivi per accedere a molti altri servizi.

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, elimina il progetto. Se hai utilizzato un progetto esistente e vuoi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione delle risorse del tutorial

Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial:
```
gcloud run services delete SERVICE-NAME
```
Dove SERVICE-NAME è il nome del servizio che hai scelto.

Puoi anche eliminare i servizi Cloud Run dalla console Google Cloud.
Rimuovi la configurazione della regione predefinita di gcloud aggiunta durante la configurazione del tutorial:
```
 gcloud config unset run/region
```
Rimuovi la configurazione del progetto:
```
 gcloud config unset project
```
Elimina le altre risorse Google Cloud create in questo tutorial:

Passaggi successivi

Approfondisci la connessione da Cloud Run a Cloud SQL
Scopri di più sui metodi di accesso e sulla gestione degli utenti con Identity Platform
Esamina altri modi per autenticare sviluppatori, servizi e utenti dei servizi di cui è stato eseguito il deployment in Cloud Run
Esplora altre demo, tutorial ed esempi di Cloud Run

Tutorial sull'autenticazione dell'utente finale per Cloud Run

Obiettivi

Costi

Prima di iniziare

Ruoli obbligatori

Configurazione delle impostazioni predefinite per gcloud in corso...

Località di Cloud Run

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Recupero dell'esempio di codice

Node.js

Python

Java

Node.js

Python

Java

Visualizzare l'architettura

Comprensione del codice di base

Integrazione con Identity Platform: codice lato client

Integrazione con Identity Platform: codice lato server

Node.js

Python

Java

Connessione del server a Cloud SQL

Node.js

Python

Java

Gestione della configurazione sensibile con Secret Manager

Node.js

Python

Java

Configurazione di Identity Platform

Deployment del servizio

Node.js

Python

Java

Node.js

Python

Java

Tocchi finali

Provalo

Esegui la pulizia

Elimina il progetto

Eliminazione delle risorse del tutorial

Passaggi successivi

Configurazione delle impostazioni predefinite per `gcloud` in corso...