Gestire l'accesso con privilegi just-in-time ai progetti

Last reviewed 2024-07-22 UTC

---

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

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

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

Quando segui il principio del privilegio minimo, concedi agli utenti un accesso sufficiente per svolgere le attività quotidiane, ma non possono fare altro. Seguire questo principio ti aiuta a ridurre i rischi. Tuttavia, può creare problemi quando a volte devono eseguire un'azione con privilegi, ad esempio per gestire un incidente imprevisto. Gli esempi includono la risoluzione dei problemi un problema in un sistema di produzione o la risoluzione di un problema che comporta e i dati sensibili.

Un modo per risolvere questo problema è fornire privilegio just-in-time l'accesso privilegiato, ovvero per fornire accesso privilegiato solo se necessario. Un'idea fondamentale della gestione degli accessi con privilegi just-in-time è distinguere tra accesso permanente e accesso idoneo:

• L'accesso permanente viene applicato fino a quando non lo revochi. Seguendo i principi del privilegio minimo, è meglio limitare l'accesso permanente e fornirgli solo solo ai pochi utenti.
• L'accesso idoneo non viene applicato immediatamente. Un utente a cui è stato concesso l'accesso idoneo a un progetto deve invece attivarlo esplicitamente prima di poter accedere al progetto. Devono anche fornire una giustificazione per questo. Una volta attivato l'accesso dell'utente, scade automaticamente dopo un breve periodo.

L'utilizzo della gestione degli accessi con privilegi just-in-time può aiutarti a svolgere quanto segue:

• Riduci il rischio di modifiche o eliminazioni accidentali Google Cloud. Ad esempio, se gli utenti dispongono dell'accesso privilegiato solo quando è necessario, questo aiuta a impedire loro di eseguire script in altri momenti che influiscono involontariamente su risorse che non dovrebbero essere in grado di modificare.
• Crea un audit trail che indichi perché sono stati attivati i privilegi.
• Eseguire controlli e revisioni per analizzare le attività passate.

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

Just-In-Time Access è un'applicazione open source progettata per funzionare su App Engine o Cloud Run e consente di implementare l'accesso privilegiato just-in-time alle risorse Google Cloud. L'applicazione consente ad amministratori, utenti e revisori di svolgere le seguenti attività:

• Gli amministratori possono concedere un ruolo a un utente o a un gruppo idoneo aggiungendo quanto segue Condizione IAM:

  has({}.jitAccessConstraint)
  

• Gli utenti possono cercare i progetti e i ruoli a cui sono idonei l'accesso utilizzando l'applicazione Just-In-Time Access.

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

  

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

  

  Dopo che l'utente ha attivato un ruolo, l'accesso Just-in-Time concede all'utente l'accesso temporaneo al progetto.

• Gli addetti ai controlli possono utilizzare Cloud Logging per esaminare quando e perché i ruoli idonei sono stati attivati dagli utenti.

Per proteggere l'applicazione da accessi non autorizzati, è possibile accedere all'applicazione di accesso Just-In-Time solo tramite Identity-Aware Proxy (IAP). Grazie a IAP, un amministratore può stabilire quali utenti autorizzati ad accedere a Just-In-Time e quali condizioni aggiuntive che questi utenti devono soddisfare per ottenere l'accesso.

Prima di iniziare

Prima di eseguire il deployment dell'applicazione di accesso Just-in-Time, devi decidere per quale parte della gerarchia delle risorse vuoi gestire l'accesso privilegiato Just-in-Time. Puoi gestire l'accesso per le seguenti risorse:

• Un singolo progetto
• Una cartella contenente più progetti
• Tutti i progetti della tua organizzazione

Per completare il deployment, hai bisogno di quanto segue:

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

Inoltre, devi disporre di un progetto Google Cloud in cui eseguire il deployment dell'applicazione Accesso Just-In-Time.

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

   Go to project selector

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

Esegui il deployment dell'accesso just-in-time

Questa sezione descrive come eseguire il deployment dell'applicazione di accesso Just-In-Time 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. Ti consigliamo quindi di utilizzare App Engine a meno che tu non stia eseguendo il deployment in una regione che non supporta App Engine, se non puoi usare App Engine per altri motivi.

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

In questa sezione si presuppone che tu sia un amministratore.

Configura il tuo progetto Google Cloud

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

   App Engine

   Enable the Cloud Asset Inventory, Resource Manager, Identity-Aware Proxy, Container Registry, Cloud Build, Identity and Access Management, and Directory APIs.

   Enable the APIs

   Cloud Run

   Enable the Cloud Asset Inventory, Resource Manager, Identity-Aware Proxy, Container Registry, Cloud Run, Compute Engine, Identity and Access Management, and Directory APIs.

   Enable the APIs

2. Apri Cloud Shell.

   Apri Cloud Shell

3. Imposta una variabile di ambiente che contenga ID progetto:

   gcloud config set project PROJECT_ID
   

   Sostituisci PROJECT_ID con l'ID del tuo progetto.

4. Crea un account di servizio per l'applicazione Accesso Just-in-Time:

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

5. Consenti all'applicazione di creare token utilizzando il proprio account di servizio concedendo all'applicazione 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 API Directory e, facoltativamente, di gestire flussi di lavoro di approvazione da più parti.

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

Ora concedi il ruolo Amministratore IAM del progetto all'account di servizio dell'applicazione. Questo ruolo consente all'applicazione di accesso Just-In-Time di creare Associazioni IAM quando deve concedere l'accesso just-in-time.

Poiché il ruolo Amministratore IAM progetto dispone di 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 concedendo a qualsiasi utente il ruolo Proprietario o Editor.
• Limita il numero di utenti che possono simulare l'identità dell'account di servizio. Gli utenti che dovrebbero essere in grado di eseguire questa operazione di 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 del progetto all'account di servizio, svolgi quanto segue:

1. Concedi il ruolo di Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin) e Ruolo Visualizzatore di asset cloud (roles/cloudasset.viewer) per la parte del 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 Il progetto Google Cloud per il quale vuoi gestire l'accesso. Questo progetto è diversa da quella per 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 il ID della tua organizzazione.

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

L'applicazione Just-in-Time Access ti consente di concedere l'accesso idoneo a un un utente specifico o a un intero gruppo. Per valutare le iscrizioni ai gruppi, è necessario l'applicazione deve disporre dell'autorizzazione per leggere le informazioni sulle iscrizioni ai gruppi dal tuo un account Cloud Identity o Google Workspace.

Concedere all'account di servizio dell'applicazione l'autorizzazione di accesso al gruppo di lettura. ad esempio, segui questi passaggi:

1. Apri la Console di amministrazione Google e accedi come utente super amministratore.

2. Vai ad Account > Ruoli amministratore:

   Vai a Ruoli amministratore

3. Fai clic su Lettore di gruppi > Amministratori.

4. Fai clic su Assegna account di servizio.

5. Inserisci il seguente indirizzo email:

   jitaccess@PROJECT_ID.iam.gserviceaccount.com
   

   Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

6. Fai clic su Aggiungi.

7. Fai clic su Assegna ruolo.

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

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

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

   Vai a Impostazioni account

2. Copia l'ID cliente del tuo account. L'ID cliente inizia con C.

   L'ID cliente ti servirà in un secondo momento.

3. Chiudi la Console di amministrazione.

Esegui il deployment dell'applicazione

Ora puoi eseguire il deployment dell'applicazione Just-in-Time Access in in App Engine o Cloud Run.

App Engine

Per eseguire il deployment dell'applicazione di accesso Just-In-Time in App Engine, svolgi i seguenti passaggi.

1. In Cloud Shell, imposta una variabile di ambiente contenente 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.

2. Crea un'applicazione App Engine:

   gcloud app create --region LOCATION
   

   Sostituisci LOCATION con un località App Engine supportata.

3. Concedi all'account di servizio predefinito di App Engine Writer Create-on-push Artifact Registry (roles/artifactregistry.createOnPushWriter) e Storage Admin (roles/storage.admin) per consentire ad App Engine per utilizzare Artifact Registry.

   PROJECT_ID=$(gcloud config get-value core/project)
   gcloud projects add-iam-policy-binding $PROJECT_ID \
       --member "serviceAccount:$[e-mail]" \
       --role "roles/artifactregistry.createOnPushWriter" \
       --condition None
   gcloud projects add-iam-policy-binding $PROJECT_ID\
       --member "serviceAccount:$[e-mail]" \
       --role "roles/storage.admin" \
       --condition None
   

4. Clona il Repository GitHub e passa al ramo latest:

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

5. Crea un file di configurazione per l'applicazione di accesso Just-In-Time:

   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, vedi Opzioni di configurazione nel repository GitHub associato.

6. Esegui il deployment dell'applicazione:

   gcloud app deploy --appyaml app.yaml
   

   Prendi nota del target url nell'output. Si tratta dell'URL pubblico dell'applicazione di accesso Just-in-Time.

   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 Just-In-Time Access in Cloud Run: segui questi passaggi.

1. In Cloud Shell, imposta una variabile di ambiente contenente 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.

2. Seleziona una regione in cui eseguire il deployment:

   gcloud config set run/region REGION
   

   Sostituisci REGION con una regione che supporta Cloud Run.

3. Crea un servizio di backend:

   gcloud compute backend-services create jitaccess-backend \
     --load-balancing-scheme=EXTERNAL \
     --global
   

   In un secondo momento, utilizzerai questo servizio di backend per configurare un bilanciatore del carico e un IAP.

4. Clona il Repository GitHub e passa al ramo latest:

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

5. Crea l'applicazione ed esegui il push dell'immagine del contenitore 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
   

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

7. Esegui il deployment dell'applicazione:

   gcloud run services replace app.yaml
   

Configura un bilanciatore del carico

Ora configura un bilanciatore del carico per l'applicazione di accesso Just-In-Time.

App Engine

App Engine configura automaticamente il bilanciatore del carico.

Cloud Run

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

1. Prenota un indirizzo IP esterno statico per il bilanciatore del carico:

   gcloud compute addresses create jitaccess-ip --global
   

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

3. Cerca l'indirizzo IP del bilanciatore del carico:

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

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

   Nota: la propagazione del nuovo record DNS può richiedere diversi minuti o ore. Durante questo periodo, il certificato SSL gestito non può essere utilizzato. Per maggiori dettagli, consulta la sezione Risolvere i problemi relativi ai certificati gestiti da Google.

5. Creare un gruppo di endpoint di rete serverless per il servizio Cloud Run e connetterlo al backend servizio:

   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)
   

6. Crea un frontend del bilanciatore del carico che utilizzi l'indirizzo IP esterno e inoltri 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
   

Configurare Identity-Aware Proxy

Ora configura l'IAP per l'applicazione di accesso Just-In-Time.

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

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

   Vai a IAP

3. Imposta IAP su enabled.

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

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

   Vai a IAM

2. Fai clic su Concedi l'accesso e imposta i seguenti valori:

   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 Just-In-Time Access, ma il ruolo non gli consente di accedere ad alcuna risorse aggiuntive.

3. Fai clic su Salva.

L'applicazione dell'associazione del ruolo potrebbe richiedere alcuni minuti.

App Engine

La configurazione IAP è ora completa.

Cloud Run

Per completare la configurazione di 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-$[e-mail]" \
  --role "roles/run.invoker"

Testa l'accesso just-in-time

Ora puoi testare la procedura di concessione dell'accesso idoneo e la procedura di utilizzo dell'applicazione di accesso just-in-time per attivare l'accesso idoneo.

Concedere l'accesso idoneo

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

1. 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.
2. Nella pagina IAM, fai clic su Concedi l'accesso.
3. Inserisci l'indirizzo email del secondo utente Cloud Identity o Google Workspace e seleziona un ruolo, ad esempio Progetto > Browser.
4. Fai clic su Aggiungi condizione.
5. Inserisci un titolo, ad esempio Eligible for JIT access.

6. Seleziona Editor condizioni e inserisci la seguente espressione CEL:

   has({}.jitAccessConstraint)
   

7. Salva le modifiche.

Attiva l'accesso

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

1. Apri una finestra del browser in incognito e vai all'URL dell'applicazione di accesso Just-In-Time che hai annotato in precedenza.
2. Accedi con l'account dell'utente a cui hai concesso l'accesso idoneo.
3. Nell'applicazione Accesso Just-In-Time, seleziona un ruolo e una risorsa per cui vuoi attivare l'accesso.

4. Inserisci una motivazione, ad esempio testing, quindi fai clic su Richiedi l'accesso.

   Nella pagina successiva, noterai che l'accesso è stato temporaneamente attivato.

Analisi dei log

Ora puoi tornare all'utente amministrativo ed esaminare il log.

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

   Vai a Esplora log

2. Imposta Mostra query su attivata.

3. Inserisci la seguente query:

   labels.event="api.activateRole"
   

4. 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",
       ...
     },
   ...
   }
   

   Tieni presente che è stato creato un record di log per ogni ruolo attivato. Il record del log include un insieme di etichette che puoi utilizzare per creare filtri personalizzati.

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

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

Questa sezione presuppone che tu sia un amministratore.

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

   Apri Cloud Shell

2. Imposta una variabile di ambiente contenente il tuo ID progetto:

   gcloud config set project PROJECT_ID
   

   Sostituisci PROJECT_ID con l'ID del tuo progetto.

3. Clona il repository GitHub e passa al ramo latest:

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

4. Scarica il file di configurazione 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 tuo deployment di Cloud Run esistente.

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

6. 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 da più parti.
• Scopri come utilizzarli accesso sensibile al contesto per un accesso sicuro al sistema Just-In-Time Access.
• Scopri di più su Condizioni IAM.
• Configura Un dominio personalizzato per l'applicazione Just-In-Time Access.
• Per altre architetture di riferimento, diagrammi e best practice, esplora il Centro architetture cloud.