Gestire l'accesso privilegiato just-in-time ai progetti

Last reviewed 2024-01-04 UTC

Questo documento descrive come utilizzare uno strumento open source per implementare l'accesso privilegiato just-in-time ai progetti Google Cloud. L'accesso con privilegi just-in-time consente di concedere l'accesso temporaneo ai progetti a un insieme limitato di utenti solo quando è necessario l'accesso.

Il documento è destinato agli amministratori che gestiscono l'accesso degli utenti alle risorse Google Cloud. Si presume che tu abbia familiarità con Google Cloud, Identity and Access Management (IAM) e concetti correlati.

Panoramica della gestione degli accessi con privilegi just-in-time

Se segui il principio del privilegio minimo, concedi agli utenti un accesso sufficiente per poter svolgere le attività quotidiane, ma non possono fare di più. Seguire questo principio aiuta a ridurre i rischi. Tuttavia, può creare attriti per gli utenti quando a volte devono eseguire un'azione privilegiata, ad esempio per far fronte a un incidente imprevisto. Gli esempi includono la risoluzione di un problema in un sistema di produzione o che riguarda dati sensibili.

Un modo per risolvere questo problema è fornire un accesso privilegiato just-in-time, ovvero un accesso privilegiato solo se necessario. Un'idea chiave della gestione degli accessi privilegiati just-in-time è la distinzione tra accesso permanente e accesso idoneo:

L'accesso permanente si applica finché non lo revochi. Seguendo il principio del privilegio minimo, è preferibile limitare l'accesso permanente e fornirlo solo ai pochi utenti autorizzati.
L'accesso idoneo non si applica immediatamente. Invece, un utente a cui è stato concesso l'accesso idoneo a un progetto deve attivare esplicitamente tale accesso prima di poter accedere al progetto. Devono inoltre fornire una motivazione. Dopo l'attivazione dell'accesso dell'utente, l'accesso scadrà automaticamente dopo un breve periodo di tempo.

L'uso della gestione degli accessi con privilegi just-in-time può aiutarti a:

Riduci il rischio che qualcuno modifichi o elimini accidentalmente le risorse. Ad esempio, se gli utenti hanno l'accesso privilegiato solo quando è necessario, contribuisce a impedire l'esecuzione di script in altri momenti che incidono involontariamente su risorse che non dovrebbero essere in grado di modificare.
Crea un audit trail che indichi il motivo dell'attivazione dei privilegi.
Effettua controlli e revisioni per analizzare le attività passate.

Utilizzare l'accesso just-in-time per implementare l'accesso con privilegi

L'accesso just-in-time è un'applicazione open source progettata per l'esecuzione su App Engine o Cloud Run e consente di implementare l'accesso privilegiato just-in-time alle risorse di Google Cloud. L'applicazione consente agli amministratori, agli utenti e ai revisori di eseguire le seguenti attività:

Gli amministratori possono concedere un ruolo a un utente o a un gruppo e renderlo idoneo aggiungendo la seguente condizione IAM:
```
has({}.jitAccessConstraint)
```
Gli utenti possono cercare progetti e ruoli a cui sono idonei utilizzando l'applicazione Just-In-Time Access.

Il seguente screenshot dell'applicazione Just-In-Time Access mostra un elenco di ruoli per i quali un utente è idoneo in un progetto:

Possono quindi attivare uno o più ruoli e fornire una giustificazione per ottenere l'accesso:

Dopo che un utente ha attivato un ruolo, l'accesso just-in-time concede all'utente l'accesso temporaneo al progetto.
Gli auditori possono utilizzare Cloud Logging per verificare quando e perché i ruoli idonei sono stati attivati dagli utenti.

Per proteggere l'applicazione da accessi non autorizzati, è possibile accedere all'applicazione Just-In-Time Access solo tramite Identity-Aware Proxy (IAP). Con IAP, un amministratore può specificare a quali utenti deve essere consentito l'accesso just-in-time e quali condizioni aggiuntive che tali utenti devono soddisfare per ottenere l'accesso.

Prima di iniziare

Prima di eseguire il deployment dell'applicazione Just-in-Time Access, devi decidere per quale parte della gerarchia di risorse gestire l'accesso con privilegi just-in-time. Puoi gestire l'accesso per le seguenti risorse:

Un singolo progetto
Una cartella che contiene più progetti
Tutti i progetti della tua organizzazione

Per completare il deployment, ti serve quanto segue:

Accesso come super amministratore all'account Cloud Identity o Google Workspace corrispondente all'organizzazione Google Cloud in uso.
Autorizzazione per modificare il criterio IAM del progetto, della cartella o dell'organizzazione che vuoi gestire utilizzando l'accesso just-in-time.
Un secondo utente di Cloud Identity o Google Workspace che puoi utilizzare per testare l'accesso.

È necessario anche un progetto Google Cloud in cui eseguire il deployment dell'applicazione accesso just-in-time.

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.

Esegui il deployment dell'accesso just-in-time

Questa sezione descrive come eseguire il deployment dell'applicazione Just-In-Time Access in App Engine o Cloud Run.

Il deployment dell'applicazione di accesso just-in-time in Cloud Run richiede una configurazione più complessa rispetto al deployment dell'applicazione in App Engine. Consigliamo quindi di utilizzare App Engine, a meno che tu non stia eseguendo il deployment in una regione che non supporta App Engine o se non puoi utilizzare App Engine per altri motivi.

Il codice per l'accesso Just-In-Time si trova in un repository GitHub.

Questa sezione presuppone che tu sia un amministratore.

Configura il tuo progetto Google Cloud

Nella console Google Cloud, passa al tuo progetto e abilita le API richieste:

App Engine

Abilita le API Cloud Asset Inventory, Resource Manager, Identity-Aware Proxy, Container Registry, Cloud Build, Identity and Access Management e Directory.
Abilita le API

Cloud Run

Abilita le API Cloud Asset Inventory, Resource Manager, Identity-Aware Proxy, Container Registry, Cloud Run, Compute Engine, Identity and Access Management e Directory.
Abilita le API
Apri Cloud Shell.

Apri Cloud Shell
Imposta una variabile di ambiente che contenga il tuo ID progetto:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con l'ID del progetto.

Crea un account di servizio per l'applicazione Just-in-Time Access:

SERVICE_ACCOUNT=$(gcloud iam service-accounts create jitaccess --display-name "Just-In-Time Access" --format "value(email)")

Consenti all'applicazione di creare token utilizzando il relativo account di servizio concedendo il ruolo Creatore token account di servizio (roles/iam.serviceAccountTokenCreator):
```
gcloud iam service-accounts add-iam-policy-binding $SERVICE_ACCOUNT \
  --member "serviceAccount:$SERVICE_ACCOUNT" \
  --role "roles/iam.serviceAccountTokenCreator"
```
L'applicazione utilizza l'autorizzazione per creare token per accedere all'API Directory e, facoltativamente, per gestire i flussi di lavoro di approvazione di più parti.

Concedi all'applicazione accesso just-in-time l'autorizzazione per gestire le associazioni IAM

Ora concedi il ruolo Amministratore IAM progetto all'account di servizio dell'applicazione. Questo ruolo consente all'applicazione Accesso just-in-time di creare associazioni IAM temporanee quando deve concedere l'accesso just-in-time.

Poiché il ruolo Amministratore IAM progetto ha privilegi elevati, devi limitare l'accesso all'account di servizio dell'applicazione e al progetto che la contiene.

Segui queste linee guida:

Limita il numero di utenti che possono accedere al progetto ed evita di concedere a nessun utente il ruolo Proprietario o Editor.
Limita il numero di utenti che possono impersonare l'account di servizio. Tra gli utenti che dovrebbero essere in grado di eseguire questa rappresentazione includono quelli che dispongono del ruolo Utente account di servizio o del ruolo Creatore token account di servizio.

Per concedere il ruolo Amministratore IAM progetto all'account di servizio:

Concedi il ruolo Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin) e il ruolo Visualizzatore di asset cloud (roles/cloudasset.viewer) alla parte della gerarchia delle risorse per cui vuoi gestire l'accesso con privilegi just-in-time:

Progetto

SCOPE_ID=RESOURCE_PROJECT_ID
SCOPE_TYPE=projects

gcloud projects add-iam-policy-binding $SCOPE_ID \
    --member "serviceAccount:$SERVICE_ACCOUNT" \
    --role "roles/resourcemanager.projectIamAdmin" \
    --condition None

gcloud projects add-iam-policy-binding $SCOPE_ID \
    --member "serviceAccount:$SERVICE_ACCOUNT" \
    --role "roles/cloudasset.viewer" \
    --condition None

Sostituisci RESOURCE_PROJECT_ID con l'ID del progetto Google Cloud per cui vuoi gestire l'accesso. Questo progetto è diverso da quello in cui stai eseguendo il deployment dell'accesso just-in-time.

Cartella

SCOPE_ID=RESOURCE_FOLDER_ID
SCOPE_TYPE=folders

gcloud resource-manager folders add-iam-policy-binding $SCOPE_ID \
    --member "serviceAccount:$SERVICE_ACCOUNT" \
    --role "roles/resourcemanager.projectIamAdmin" \
    --condition None
gcloud resource-manager folders add-iam-policy-binding $SCOPE_ID \
    --member "serviceAccount:$SERVICE_ACCOUNT" \
    --role "roles/cloudasset.viewer" \
    --condition None

Sostituisci RESOURCE_FOLDER_ID con l'ID della cartella che contiene i progetti per i quali vuoi gestire l'accesso.

Organizzazione

SCOPE_ID=ORGANIZATION_ID
SCOPE_TYPE=organizations

gcloud organizations add-iam-policy-binding $SCOPE_ID \
    --member "serviceAccount:$SERVICE_ACCOUNT" \
    --role "roles/resourcemanager.projectIamAdmin" \
    --condition None
gcloud organizations add-iam-policy-binding $SCOPE_ID \
    --member "serviceAccount:$SERVICE_ACCOUNT" \
    --role "roles/cloudasset.viewer" \
    --condition None

Sostituisci ORGANIZATION_ID con l'ID della tua organizzazione.

Concedi l'accesso per consentire all'applicazione di risolvere le iscrizioni ai gruppi

L'applicazione Just-In-Time Access consente di concedere l'accesso idoneo a un utente specifico o a un intero gruppo. Per valutare le iscrizioni ai gruppi, l'applicazione deve essere autorizzata a leggere le informazioni sulle iscrizioni ai gruppi dal tuo account Cloud Identity o Google Workspace.

Per concedere l'autorizzazione di accesso all'account di servizio dell'applicazione per leggere le iscrizioni dei gruppi, segui questi passaggi:

Apri la Console di amministrazione Google e accedi come utente super amministratore.
Vai ad Account > Ruoli amministratore:

Vai a Ruoli amministratore
Fai clic su Lettore di Gruppi > Amministratori.
Fai clic su Assegna account di servizio.
Inserisci il seguente indirizzo email:
```
jitaccess@PROJECT_ID.iam.gserviceaccount.com
```
Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.
Fai clic su Aggiungi.
Fai clic su Assegna ruolo.

Cerca l'ID cliente del tuo account Cloud Identity o Google Workspace

Per valutare le iscrizioni ai gruppi utilizzando l'API Directory, l'applicazione Just-In-Time Access richiede l'ID cliente dell'account Cloud Identity o Google Workspace. Per cercare questo ID:

Nella Console di amministrazione Google, vai ad Account > Impostazioni account:

Vai a Impostazioni account
Copia l'ID cliente dell'account. L'ID cliente inizia con C.

L'ID cliente ti servirà in un passaggio successivo.
Chiudi la Console di amministrazione.

Esegui il deployment dell'applicazione

Ora è tutto pronto per eseguire il deployment dell'applicazione di accesso just-in-time su App Engine o Cloud Run.

App Engine

Per eseguire il deployment dell'applicazione di accesso just-in-time in App Engine, devi eseguire i seguenti passaggi.

In Cloud Shell, imposta una variabile di ambiente che contenga l'ID cliente del tuo account Cloud Identity o Google Workspace:
```
ACCOUNT_CUSTOMER_ID=CUSTOMER_ID
```
Sostituisci CUSTOMER_ID con l'ID cliente che hai cercato in precedenza.
Crea un'applicazione App Engine:
```
gcloud app create --region LOCATION
```
Sostituisci LOCATION con una località App Engine supportata.

Clona il repository GitHub e passa al ramo latest:

git clone https://github.com/GoogleCloudPlatform/jit-access.git
cd jit-access/sources
git checkout latest

Crea un file di configurazione per l'applicazione Just-In-Time Access:

cat << EOF > app.yaml

runtime: java17
instance_class: F2
service_account: $SERVICE_ACCOUNT
env_variables:
    RESOURCE_SCOPE: $SCOPE_TYPE/$SCOPE_ID
    RESOURCE_CATALOG: AssetInventory
    RESOURCE_CUSTOMER_ID: $ACCOUNT_CUSTOMER_ID
    ACTIVATION_TIMEOUT: 60
    JUSTIFICATION_HINT: "Bug or case number"
    JUSTIFICATION_PATTERN: ".*"
EOF

In questo file di configurazione puoi personalizzare i valori delle variabili. Per un elenco delle impostazioni, consulta la pagina Opzioni di configurazione nel repository GitHub associato.

Esegui il deployment dell'applicazione:
```
gcloud app deploy --appyaml app.yaml
```
Prendi nota di target url nell'output. Questo sarà l'URL pubblico dell'applicazione Just-in-Time Access.

Se viene visualizzato il messaggio di errore NOT_FOUND: Unable to retrieve P4SA, riprova a eseguire il comando.

Cloud Run

Per eseguire il deployment dell'applicazione di accesso just-in-time in Cloud Run, segui questi passaggi.

In Cloud Shell, imposta una variabile di ambiente che contenga l'ID cliente del tuo account Cloud Identity o Google Workspace:
```
ACCOUNT_CUSTOMER_ID=CUSTOMER_ID
```
Sostituisci CUSTOMER_ID con l'ID cliente che hai cercato in precedenza.
Seleziona una regione in cui eseguire il deployment:
```
gcloud config set run/region REGION
```
Sostituisci REGION con una regione che supporta Cloud Run.
Crea un servizio di backend:
```
gcloud compute backend-services create jitaccess-backend \
  --load-balancing-scheme=EXTERNAL \
  --global
```
In seguito, utilizzerai questo servizio di backend per configurare un bilanciatore del carico e IAP.

Clona il repository GitHub e passa al ramo latest:

git clone https://github.com/GoogleCloudPlatform/jit-access.git
cd jit-access/sources
git checkout latest

Crea l'applicazione ed esegui il push dell'immagine container in Container Registry:

PROJECT_ID=$(gcloud config get-value core/project)

docker build -t gcr.io/$PROJECT_ID/jitaccess:latest .
docker push gcr.io/$PROJECT_ID/jitaccess:latest

Crea un file di configurazione per l'applicazione Just-In-Time Access:

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format 'value(projectNumber)')
REGION=$(gcloud config get-value run/region)
IAP_BACKEND_SERVICE_ID=$(gcloud compute backend-services describe jitaccess-backend --global --format 'value(id)')

cat << EOF > app.yaml

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: jitaccess
  namespace: $PROJECT_NUMBER
  labels:
    cloud.googleapis.com/location: $REGION
  annotations:
    run.googleapis.com/ingress: internal-and-cloud-load-balancing
spec:
  template:
    spec:
      serviceAccountName: $SERVICE_ACCOUNT
      containers:
      - image: gcr.io/$PROJECT_ID/jitaccess:latest
        env:
        - name: RESOURCE_SCOPE
          value: "$SCOPE_TYPE/$SCOPE_ID"
        - name: RESOURCE_CATALOG
          value: "AssetInventory"
        - name: RESOURCE_CUSTOMER_ID
          value: "$ACCOUNT_CUSTOMER_ID"
        - name: ACTIVATION_TIMEOUT
          value: "60"
        - name: JUSTIFICATION_HINT
          value: "Bug or case number"
        - name: JUSTIFICATION_PATTERN
          value: ".*"
        - name: IAP_BACKEND_SERVICE_ID
          value: "$IAP_BACKEND_SERVICE_ID"
EOF

In questo file di configurazione puoi personalizzare i valori delle variabili. Per un elenco delle impostazioni, consulta la pagina Opzioni di configurazione nel repository GitHub associato.

Esegui il deployment dell'applicazione:
```
gcloud run services replace app.yaml
```

Configura un bilanciatore del carico

Ora configurerai un bilanciatore del carico per l'applicazione Just-In-Time Access.

App Engine

App Engine configura automaticamente il bilanciatore del carico.

Cloud Run

Configura un bilanciatore del carico HTTPS per il tuo servizio Cloud Run:

Prenota un indirizzo IP esterno statico per il bilanciatore del carico:
```
gcloud compute addresses create jitaccess-ip --global
```
Crea un certificato SSL gestito per il bilanciatore del carico:
```
gcloud compute ssl-certificates create jitaccess \
  --domains PUBLIC_FQDN \
  --global
```
dove PUBLIC_FQDN è il nome di dominio completo (FQDN) pubblico che vuoi utilizzare, ad esempio jitaccess.example.com.

Cerca l'indirizzo IP del bilanciatore del carico:

gcloud compute addresses describe jitaccess-ip \
  --global \
  --format=value\(address\)

Crea un record A DNS nella zona DNS pubblica che punta all'indirizzo IP del bilanciatore del carico. Il nome completo del record DNS deve corrispondere al nome che hai utilizzato per il certificato SSL.

Nota: la propagazione del nuovo record DNS può richiedere diversi minuti od ore. Durante questo periodo, non è possibile utilizzare il certificato SSL gestito. Per maggiori dettagli, consulta Risoluzione dei problemi relativi ai certificati gestiti da Google.

Crea un gruppo di endpoint di rete serverless per il servizio Cloud Run e connettilo al servizio di backend:

gcloud compute network-endpoint-groups create jitaccess \
  --region $(gcloud config get-value run/region) \
  --network-endpoint-type=serverless  \
  --cloud-run-service jitaccess
gcloud compute backend-services add-backend jitaccess-backend \
  --global \
  --network-endpoint-group jitaccess \
  --network-endpoint-group-region $(gcloud config get-value run/region)

Crea un frontend del bilanciatore del carico che utilizza l'indirizzo IP esterno e inoltra il traffico al servizio di backend:

gcloud compute url-maps create jitaccess \
  --default-service jitaccess-backend
gcloud compute target-https-proxies create jitaccess-proxy \
  --ssl-certificates jitaccess \
  --url-map jitaccess
gcloud compute forwarding-rules create jitaccess-https \
  --load-balancing-scheme EXTERNAL \
  --address jitaccess-ip \
  --target-https-proxy jitaccess-proxy \
  --global \
  --ports=443

Configura Identity-Aware Proxy

Ora configuri IAP per l'applicazione Just-In-Time Access.

In Cloud Shell, configura una schermata per il consenso OAuth:

gcloud iap oauth-brands create \
    --application_title "Just-In-Time Access" \
    --support_email=$(gcloud config get core/account)

Nella console Google Cloud, vai a Sicurezza > Identity-Aware Proxy.

Vai a IAP
Imposta IAP su enabled.

Ora devi definire gli utenti autorizzati ad accedere all'applicazione Just-In-Time Access. Puoi concedere l'accesso a singoli utenti, gruppi o a un intero dominio.

Nella console Google Cloud, vai a IAM e amministrazione > IAM.

Vai a IAM
Fai clic su Concedi l'accesso e imposta i valori seguenti:
1. Nell'elenco delle entità, seleziona un utente, un gruppo o un dominio.
2. Nell'elenco dei ruoli, seleziona Utente app web con protezione IAP.
Il ruolo Utente app web con protezione IAP consente agli utenti di aprire l'applicazione di accesso just-in-time, ma il ruolo non fornisce ancora l'accesso a risorse aggiuntive.
Fai clic su Salva.

L'applicazione dell'associazione dei ruoli può richiedere alcuni minuti.

App Engine

La configurazione IAP è stata completata.

Cloud Run

Per completare la configurazione IAP, concedi il ruolo Invoker di Cloud Run (roles/run.invoker) all'agente di servizio utilizzato da IAP:

PROJECT_NUMBER=$(gcloud projects list \
  --filter $(gcloud config get-value project) \
  --format "value(PROJECT_NUMBER)")

gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
  --member "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-iap.iam.gserviceaccount.com" \
  --role "roles/run.invoker"

Testa l'accesso just-in-time

Ora puoi testare la procedura per concedere l'accesso idoneo e la procedura di utilizzo dell'applicazione Just-In-Time Access per attivare l'accesso idoneo.

Concedi l'accesso idoneo

Per iniziare, concedi l'accesso idoneo a un secondo utente di Cloud Identity o Google Workspace.

Nella console Google Cloud, utilizza l'elenco dei progetti per selezionare un progetto che fa parte della gerarchia delle risorse gestita dall'applicazione di accesso just-in-time.
Nella pagina IAM, fai clic su Concedi l'accesso.
Inserisci l'indirizzo email del tuo secondo utente Cloud Identity o Google Workspace e seleziona un ruolo, ad esempio Progetto > Browser.
Fai clic su Aggiungi condizione.
Inserisci un titolo, ad esempio Eligible for JIT access.
Seleziona Editor condizioni, quindi inserisci la seguente espressione CEL:
```
has({}.jitAccessConstraint)
```
Salva le modifiche.

Attiva l'accesso

Ora puoi cambiare utente e richiedere l'accesso temporaneo a una risorsa.

Apri una finestra in incognito nel browser e vai all'URL dell'applicazione Just-In-Time Access annotata in precedenza.
Accedi con l'account dell'utente a cui hai concesso l'accesso idoneo.
Nell'applicazione Just-In-Time Access, seleziona un ruolo e una risorsa per cui vuoi attivare l'accesso.
Inserisci una giustificazione, ad esempio testing e fai clic su Richiedi accesso.

Nella pagina successiva, nota che il tuo accesso è stato temporaneamente attivato.

Analisi dei log

Ora puoi tornare al tuo utente amministrativo ed esaminare il log.

Nella console Google Cloud, vai a Logging > Esplora log.

Vai a Esplora log
Imposta Mostra query su enabled.
Inserisci la seguente query:
```
labels.event="api.activateRole"
```

Fai clic su Esegui query.

L'output è simile al seguente:

{
"textPayload": "User EMAIL activated role 'ROLE' on '//cloudresourcemanager.googleapis.com/projects/PROJECT_ID' for themselves",
"severity": "INFO",
"labels": {
    "resource": "//cloudresourcemanager.googleapis.com/projects/PROJECT_ID",
    "event": "api.activateRole",
    "role": "ROLE",
    "clone_id": "00c6...",
    "user": "EMAIL",
    "justification": "testing",
    ...
  },
...
}

Nota che è stato creato un record di log per ciascun ruolo attivato. Il record di log include un set di etichette che puoi utilizzare per creare filtri personalizzati.

Esegui l'upgrade dell'accesso just-in-time

Questa sezione descrive come eseguire l'upgrade di un deployment Just-In-Time Access esistente per utilizzare una versione più recente dell'applicazione o per utilizzare una configurazione diversa.

Questa sezione presuppone che tu sia un amministratore.

Nella console Google Cloud, passa al tuo progetto e apri Cloud Shell.

Apri Cloud Shell
Imposta una variabile di ambiente che contenga il tuo ID progetto:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con l'ID del progetto.

Clona il repository GitHub e passa al ramo latest:

git clone https://github.com/GoogleCloudPlatform/jit-access.git
cd jit-access/sources
git checkout latest

Scarica il file di configurazione che hai utilizzato in precedenza per eseguire il deployment dell'applicazione e salvalo in un file app.yaml:

App Engine

APPENGINE_VERSION=$(gcloud app versions list --service default --hide-no-traffic --format "value(version.id)")
APPENGINE_APPYAML_URL=$(gcloud app versions describe $APPENGINE_VERSION --service default --format "value(deployment.files.'app.yaml'.sourceUrl)")

curl -H "Authorization: Bearer $(gcloud auth print-access-token)" $APPENGINE_APPYAML_URL -o app.yaml
cat app.yaml

Se il download del file app.yaml non va a buon fine, puoi scaricare la configurazione attuale nella console Google Cloud.

Cloud Run

gcloud config set run/region REGION
gcloud run services describe jitaccess --format yaml > app.yaml

Sostituisci REGION con la regione che contiene il deployment Cloud Run esistente.

Se vuoi apportare modifiche alla configurazione, modifica il file app.yaml. Per un elenco delle impostazioni, consulta la pagina Opzioni di configurazione nel repository GitHub associato.

Esegui il deployment dell'applicazione:

App Engine

sed -i 's/java11/java17/g' app.yaml
gcloud app deploy --appyaml app.yaml

Cloud Run

PROJECT_ID=$(gcloud config get-value core/project)

docker build -t gcr.io/$PROJECT_ID/jitaccess:latest .
docker push gcr.io/$PROJECT_ID/jitaccess:latest

IMAGE=$(docker inspect --format='{{index .RepoDigests 0}}'  gcr.io/$PROJECT_ID/jitaccess)
sed -i "s|image:.*|image: $IMAGE|g" app.yaml

gcloud run services replace app.yaml

Passaggi successivi

Configura l'approvazione di più parti.
Scopri come utilizzare l'accesso sensibile al contesto per proteggere l'accesso Just-In-Time Access.
Scopri di più sulle condizioni IAM.
Configura un dominio personalizzato per l'applicazione Just-In-Time Access.
Per altre architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.