Tutorial sull'autenticazione degli utenti finali per Cloud Run

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

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 il loro animale domestico preferito.
    3. Aggiunge un token ID a una richiesta al server Cloud Run che elabora il voto.
  • Un server Cloud Run:

    1. Controlli per verificare 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 PostgresSQL 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 proprio 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 connettersi all'istanza Cloud SQL. Inoltre, utilizza un'identità di servizio con privilegi minimi per proteggere l'accesso al database.

Obiettivi

Scrivere, creare ed eseguire il deployment di un servizio in Cloud Run che mostra come:

  • Utilizza Identity Platform per autenticare un utente finale nel backend del servizio Cloud Run.

  • Creare un'identità con privilegi minimi per consentire al servizio di concedere l'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

Questo tutorial utilizza 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 beneficiare di una prova gratuita.

Prima di iniziare

  1. 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.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

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

    Abilita le API

Configurazione dei valori predefiniti di gcloud in corso...

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

  1. Imposta il progetto predefinito:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con il nome del progetto che hai creato per questo tutorial.

  2. Configura gcloud per l'area geografica scelta:

    gcloud config set run/region REGION

    Sostituisci REGION con l'area geografica Cloud Run supportata.

Località di Cloud Run

Cloud Run è a livello di regione, ossia l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google in modo che sia ridondante disponibile in tutte le zone al suo interno.

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

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

  • asia-east1 (Taiwan)
  • asia-northeast1 (Tokyo)
  • asia-northeast2 (Osaka)
  • europe-north1 (Finlandia) icona Fogliolina Bassi livelli di CO2
  • europe-southwest1 (Madrid) icona Fogliolina CO bassa2
  • europe-west1 (Belgio) icona Fogliolina CO bassa2
  • europe-west4 (Paesi Bassi)
  • europe-west8 (Milano)
  • europe-west9 (Parigi) icona Fogliolina Basso livello di CO2
  • us-central1 (Iowa) icona Fogliolina CO basso2
  • us-east1 (Carolina del Sud)
  • us-east4 (Virginia del Nord)
  • us-east5 (Columbus)
  • us-south1 (Dallas)
  • us-west1 (Oregon) icona Fogliolina Bassi livelli di CO2

Soggetto ai prezzi di Livello 2

  • 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-west2 (Londra, Regno Unito)
  • europe-west3 (Francoforte, Germania)
  • europe-west6 (Zurigo, Svizzera) icona Fogliolina Basso livello di CO2
  • northamerica-northeast1 (Montreal) icona Fogliolina CO bassa2
  • northamerica-northeast2 (Toronto) icona Fogliolina Basso livello di CO2
  • southamerica-east1 (San Paolo, Brasile) icona Fogliolina Basso CO2
  • southamerica-west1 (Santiago, Cile)
  • us-west2 (Los Angeles)
  • us-west3 (Salt Lake City)
  • us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare l'area geografica nella dashboard di Cloud Run nella Google Cloud Console.

Recupero dell'esempio di codice in corso...

Per recuperare l'esempio di codice da utilizzare:

  1. Clona il repository dell'app di esempio nella 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.

  2. Passa alla directory che contiene il codice campione 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/

Visualizzazione dell'architettura

Diagramma dell'architettura
Il diagramma mostra un accesso dell'utente finale tramite un popup di accesso di Google fornito dall'IdP, quindi viene reindirizzato nuovamente a Cloud Run con l'identità dell'utente.
  1. Un utente finale invia la prima richiesta al server Cloud Run.

  2. Il client carica il browser

  3. L'utente fornisce le credenziali di accesso tramite la finestra popup di accesso di Google di Identity Platform. All'utente che ha eseguito l'accesso viene inviato un avviso.

  4. Il controllo viene reindirizzato al server. L'utente finale vota tramite il client, che recupera un token ID da Identity Platform e lo aggiunge all'intestazione della richiesta di voto.

  5. Quando il server riceve la richiesta, verifica il token ID di Identity Platform, confermando che l'utente finale sia autenticato in modo appropriato. Il server invia il voto a Cloud SQL utilizzando le proprie credenziali.

Comprendere il codice principale

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 connetterti 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. Poi 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 correttamente, il client utilizza i metodi Firebase per coniare un token ID. Il client aggiunge al server il token ID dell'intestazione Authorization della richiesta.

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 Admin di Firebase per verificare il token User-ID inviato dal client. Se il token ID fornito ha il formato corretto, non è scaduto e è firmato correttamente, il metodo restituisce il token ID decodificato. Il server estrae la Identity Platform uid per quell'utente.

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]:
    @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, str]
) -> sqlalchemy.engine.base.Engine:
    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": "{}/{}/.s.PGSQL.5432".format(
                    db_socket_dir, cloud_sql_connection_name  # e.g. "/cloudsql"
                )  # i.e "<PROJECT-NAME>:<INSTANCE-REGION>:<INSTANCE-NAME>"
            },
        ),
        **db_config,
    )
    pool.dialect.description_encoding = None
    logger.info("Database engine initialised from unix conection")

    return pool

Java

Utilizza l'integrazione di Spring Cloud Google Cloud PostgreSQL starter per interagire con i tuoi database PostgreSQL in Google Cloud SQL utilizzando le librerie JDBC di Spring. Imposta la tua configurazione Cloud SQL per MySQL per configurare automaticamente un bean DataSource, che, insieme a JDBC Spring, fornisce un bean di oggetti JdbcTemplate che consente operazioni come query e modifiche 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 uno spazio di archiviazione centralizzato e sicuro 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]:
    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 in corso...

Identity Platform richiede la configurazione manuale in Google Cloud Console.

  1. Vai alla pagina Identity Platform Marketplace nella console Google Cloud.

    Vai alla pagina Identity Platform Marketplace

  2. Fai clic su Abilita Identity Platform. Viene creato un ID client OAuth2 con il nome: Web client (auto created by Google Service).

  3. Scarica l'ID OAuth2 generato:

    1. In una nuova finestra, vai alle API e servizi > pagina Credenziali.

      Vai alla pagina API e servizi > credenziali

    2. Nel record relativo a "Client web (creato automaticamente da Google Service)", fai clic sull'icona di download.

    3. Prendi nota di client_id e client_secret.

  4. Configura Google come fornitore:

    1. Vai alla pagina Fornitori di identità in Cloud Console.

      Vai alla pagina Provider di identità

    2. Fai clic su Aggiungi un fornitore.

    3. Seleziona Google dall'elenco.

    4. Nelle impostazioni di Configurazione dell'SDK web, inserisci i valori precedenti.

      1. ID client web: client_id

      2. Secret client web: client_secret

    5. Fai clic su Configura schermo.

      1. Seleziona Esterno per Tipo di utente.

      2. Compila i campi obbligatori (Email dell'assistenza, Email dello sviluppatore).

      3. Continua fino a raggiungere la pagina Riepilogo.

    6. In "Configura la tua applicazione", fai clic su Dettagli configurazione. Copia lo snippet nell'elemento static/config.js di esempio per inizializzare l'SDK client di Identity Platform. In alternativa, individua lo snippet della pagina di Google Cloud Console nei Dettagli di configurazione dell'applicazione e copialo nel static/config.js dell'esempio.

    7. Fai clic su Salva.

Deployment del servizio

Segui i passaggi seguenti per completare il provisioning e il deployment dell'infrastruttura oppure automatizzare il processo in Cloud Shell facendo clic su "Esegui su Google Cloud".

Esegui su Google Cloud

  1. Crea un'istanza Cloud SQL con il 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
  2. 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"
    }

  3. 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
  4. 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
  5. Concedi i ruoli per l'accesso a Secret Manager e Cloud SQL utilizzando la console o l'interfaccia a riga di comando:

    1. 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
    2. 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
  6. Crea l'immagine container utilizzando Cloud Build:

    Node.js

    gcloud builds submit --tag gcr.io/PROJECT_ID/idp-sql

    Python

    gcloud builds submit --tag gcr.io/PROJECT_ID/idp-sql

    Java

    Questo esempio utilizza Jib per creare immagini Docker utilizzando strumenti Java comuni. Jib ottimizza le build dei container senza avere il Dockerfile o installato Docker. Scopri di più sulla creazione di container Java con Jib.

    1. Utilizza l'Assistente per le credenziali gcloud per autorizzare Docker a effettuare il push a Container Registry.

      gcloud auth configure-docker

    2. Utilizza il plug-in Jib Maven per creare il container ed eseguirne il push a Container Registry.

      mvn compile jib:build -Dimage=gcr.io/PROJECT_ID/idp-sql

  7. Esegui il deployment dell'immagine container su Cloud Run utilizzando la console o l'interfaccia a riga di comando. Tieni presente che il deployment del server è stato eseguito per 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, eseguendo l'autenticazione dell'utente finale.

    gcloud run deploy idp-sql \
        --image gcr.io/PROJECT_ID/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 anche i flag --service-account, --add-cloudsql-instances e --update-secrets, che specificano l'identità del servizio, la connessione all'istanza Cloud SQL e il nome del secret con la versione rispettivamente come variabile di ambiente.

Ultimi ritocchi

Identity Platform richiede l'autorizzazione dell'URL del servizio Cloud Run come reindirizzamento consentito dopo che ha eseguito l'accesso all'utente:

  1. Per modificare il provider Google, fai clic sull'icona della penna nella pagina Provider di identità.

  2. 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 trovarlo in qualsiasi momento utilizzando:

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

Provalo

Per provare il servizio completo:

  1. Apri il browser all'URL fornito nel passaggio di deployment indicato sopra.

  2. Fai clic sul pulsante Accedi con Google e segui la procedura di autenticazione.

  3. Aggiungi il tuo voto!

    Dovrebbe avere il seguente aspetto:

    Screenshot dell&#39;interfaccia utente che mostra il conteggio dei voti per ciascun team e un elenco di voti.

Se scegli di continuare a sviluppare questi servizi, ricorda che l'accesso a Identity and Access Management (IAM) è stato limitato al resto di Google Cloud e devi 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 mantenerlo 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:

  1. In Google Cloud Console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione delle risorse del tutorial

  1. 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 Google Cloud Console.

  2. Rimuovi la configurazione predefinita di gcloud aggiunta durante l'impostazione del tutorial:

     gcloud config unset run/region
    
  3. Rimuovi la configurazione del progetto:

     gcloud config unset project
    
  4. Elimina le altre risorse Google Cloud create in questo tutorial:

Passaggi successivi