Tutorial sull'autenticazione degli utenti finali per Cloud Run

Questo tutorial mostra come creare un servizio di votazione composto da:

  • Un client basato su browser che:

    1. Utilizza Identity Platform per recuperare un token ID.
    2. Consente agli utenti di votare per il loro animale domestico preferito.
    3. Aggiunge questo token ID a una richiesta al server Cloud Run che elabora il voto.

  • Un server Cloud Run che:

    1. Controlla che l'utente finale si sia autenticato correttamente fornendo un token ID valido.
    2. Elabora il voto dell'utente finale.
    3. Utilizzando le proprie credenziali, invia il voto 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 autenticarsi utilizzando una Account Google per acquisire il proprio token ID. Tuttavia, puoi utilizzare altri fornitori o metodi di autenticazione per far accedere gli 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. Inoltre, utilizza un'identità di servizio con privilegi minimi per un accesso sicuro al database.

Obiettivi

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

  • Utilizza Identity Platform per autenticare un utente finale al Backend del servizio Cloud Run.

  • Crea un'identità con privilegi minimi per il servizio da concedere alle risorse di Google Cloud un accesso minimo.

  • Utilizza Secret Manager per gestire i dati sensibili quando colleghi il servizio Cloud Run a un database PostgreSQL.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

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

    Go to project selector

  5. Make sure that billing is enabled for your Google Cloud project.

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

    Enable the APIs

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare il tutorial: chiedi all'amministratore di concederti i seguenti ruoli IAM sul tuo progetto:

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Configurare i valori predefiniti di gcloud

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 per cui hai creato questo tutorial.

  2. Configura gcloud per la regione scelta:

    gcloud config set run/region REGION

    Sostituisci REGION con il Cloud Run supportato regione di tua scelta.

Località Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura dei tuoi servizi Cloud Run si trova in una regione specifica gestiti da Google in modo che siano disponibili in modo ridondante tutte le zone all'interno di quella regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è fondamentale i fattori necessari per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. Generalmente puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la località dell'altro account Google Cloud prodotti utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire nonché la latenza del tuo servizio.

Cloud Run è disponibile nelle regioni seguenti:

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Se hai già creato un servizio Cloud Run, puoi visualizzare nella dashboard di Cloud Run all'interno Console Google Cloud.

Recupero dell'esempio di codice

Per recuperare l'esempio di codice da utilizzare:

  1. Clona il repository dell'app di esempio nella tua macchina locale:

    Node.js 

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

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

    Python 

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

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

    Java 

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

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

  2. Passa alla directory che contiene l'esempio di Cloud Run codice:

    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 l'accesso di un utente finale tramite una finestra di dialogo di accesso a Google fornite da Identity Platform, per poi essere reindirizzati Cloud Run con l'identità dell'utente.

  1. Un utente finale invia la prima richiesta al server Cloud Run.

  2. Il client viene caricato nel browser.

  3. L'utente fornisce le credenziali di accesso tramite la finestra di dialogo Accedi con Google. da Identity Platform. L'utente che ha eseguito l'accesso riceve un avviso.

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

  5. Quando il server riceve la richiesta, verifica il token ID Identity Platform, che conferma la corretta autenticazione dell'utente finale. Il server invia quindi il voto in Cloud SQL, usando 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 per effettuare l'accesso e gestire gli utenti. Per effettuare la connessione a Identity Platform, il codice JavaScript lato client contiene il riferimento le credenziali come oggetto di configurazione e importa SDK Firebase JavaScript:

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 di nuovo 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 cliente utilizza i metodi Firebase per generare una token ID. Il client aggiunge il token ID all'intestazione Authorization della 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 Admin Firebase. per verificare il token ID utente inviato dal client. Se l'oggetto Il token ID sia nel formato corretto, non è scaduto e sia stato firmato correttamente, restituisce il token ID decodificato. Il server estrae 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]:
    """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 del 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 PostgreSQL di Google Cloud per Spring Cloud per interagire con il tuo Database PostgreSQL in Cloud SQL con le librerie JDBC di Spring. Imposta Configurazione di Cloud SQL per MySQL per la configurazione automatica di un bean DataSource che, insieme a JDBC Spring, 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 offre un'archiviazione centralizzata e sicura dei dati sensibili come la configurazione di Cloud SQL. Il server inserisce le credenziali Cloud SQL da Secret Manager in fase di esecuzione tramite una variabile di ambiente. Scopri di più su 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.");
  }
}

Configurare Identity Platform

Identity Platform richiede la configurazione manuale nella console Google Cloud.

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

    Vai alla pagina di Identity Platform Marketplace

  2. Fai clic su Abilita Identity Platform.

  3. Crea la schermata per il consenso OAuth:

    1. In una nuova finestra, vai alle API e Servizi > Pagina Credenziali

      Vai alla pagina API e Servizi > Pagina Credenziali

    2. Seleziona la pagina Schermata consenso OAuth.

    3. A scopo di test, seleziona Esterno.

    4. Fai clic su Crea.

    5. Nella finestra di dialogo Informazioni app,

      1. Fornisci il nome dell'applicazione.
      2. Seleziona una delle email di assistenza utente visualizzate.
      3. Inserisci l'indirizzo email che vuoi usare come contatto sviluppatore.

    6. Fai clic su Salva e continua.

    7. Nella finestra di dialogo Ambiti, fai clic su Salva e continua.

    8. Nella finestra di dialogo Utenti di test, fai clic su Salva e continua.

    9. Nella finestra di dialogo Riepilogo, fai clic su Torna alla dashboard.

    10. Nella sezione Stato di pubblicazione, fai clic su Pubblica app.

    11. Fai clic su Conferma.

  4. Crea e ottieni il tuo ID client e il tuo 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 Tipo di applicazione, seleziona Applicazione web e fornisci il nome.

    4. Fai clic su Crea

    5. Prendi nota di client_id e client_secret per utilizzarli in un secondo momento in questa procedura.

  5. Configurare Google come fornitore:

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

di Gemini Advanced.

Deployment del servizio

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

Esegui su Google Cloud

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

  2. Aggiungi i valori delle 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 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 un Artifact Registry:

    gcloud artifacts repositories create REPOSITORY \
    --repository-format docker \
    --location REGION
    • REPOSITORY è il nome del repository. Per ogni posizione del repository in un progetto, i nomi dei repository devono essere univoci.

  7. Crea l'immagine container con 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 utilizzando strumenti Java comuni. Jib ottimizza le build di container senza la necessità di un Dockerfile o di avere Docker installato. Scopri di più sulla creazione di container Java con Jib.

    1. Utilizza gcloud credentials helper per autorizzare Docker a eseguire il push in Artifact Registry. 

      gcloud auth configure-docker

    2. Usa il plug-in Jib Maven per creare il container ed eseguirne il push su Artifact Registry. 

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

  8. Esegui il deployment dell'immagine container in Cloud Run utilizzando la console o l'interfaccia a riga di comando. Tieni presente che viene eseguito il deployment del server per consentire l'accesso non autenticato. In questo modo l'utente può caricare il client e iniziare il processo. La verifica manualmente il token ID aggiunto alla richiesta di voto, l'autenticazione dell'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

    Nota anche i flag --service-account, --add-cloudsql-instances e --update-secrets, che specifica l'identità del servizio, l'istanza Cloud SQL connessione all'istanza e il nome del secret con la versione come ambiente rispettivamente.

Tocchi finali

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

  1. Modifica il provider Google facendo clic sull'icona della penna nella sezione Identity nella pagina Fornitori.

  2. Fai clic su Add Domain (Aggiungi dominio) sotto Authorized Domains (Domini autorizzati) nel riquadro a destra e inserisci l'URL del servizio Cloud Run.

    Puoi trovare l'URL del servizio nei log dopo la compilazione o il deployment oppure puoi trovarlo in qualsiasi momento utilizzando:

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

  3. Vai alla pagina API e Servizi > Pagina Credenziali

    1. Fai clic sull'icona a forma di matita accanto all'ID client OAuth per modificarlo e sotto il pulsante Aggiungi URI Authorized redirect URIs click the.

    2. Nel campo copia e incolla il seguente URL, poi fai clic sul pulsante Salva in fondo alla pagina.

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

Prova

Per provare il servizio completo:

  1. Apri il browser e vai all'URL fornito nel passaggio di implementazione precedente.

  2. Fai clic sul pulsante Accedi con Google e segui il flusso di autenticazione.

  3. Aggiungi il tuo voto.

    Dovrebbe avere il seguente aspetto:

    Screenshot dell&#39;interfaccia utente che mostra il numero di voti per ogni squadra e un elenco di voti.

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

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 l'aggiunta delle modifiche In questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione creato per il tutorial.

Per eliminare il progetto:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminazione delle risorse del tutorial in corso...

  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.

    I servizi Cloud Run possono essere eliminati anche Console Google Cloud.

  2. Rimuovi la configurazione predefinita della regione gcloud che hai aggiunto durante il tutorial configurazione:

     gcloud config unset run/region

  3. Rimuovi la configurazione del progetto:

     gcloud config unset project

  4. Elimina altre risorse Google Cloud create in questo tutorial:

Passaggi successivi