Gérer l'accès privilégié à des projets avec le juste-à-temps

Last reviewed 2024-01-04 UTC

Ce document explique comment utiliser un outil Open Source pour implémenter un accès privilégié aux projets Google Cloud avec le juste-à-temps. L'accès privilégié avec le juste-à-temps vous permet d'accorder un accès temporaire aux projets pour un ensemble limité d'utilisateurs seulement lorsque l'accès est nécessaire.

Ce document est destiné aux administrateurs qui gèrent l'accès des utilisateurs aux ressources Google Cloud. Nous partons du principe que vous connaissez Google Cloud, IAM (Identity and Access Management) et les concepts associés.

Présentation de la gestion des accès privilégiés avec le juste-à-temps

Lorsque vous suivez le principe du moindre privilège, vous accordez aux utilisateurs un accès suffisant pour qu'ils puissent effectuer des activités quotidiennes, mais ne puissent rien faire de plus. Le respect de ce principe vous permet de réduire les risques. Toutefois, cela peut créer des frictions pour les utilisateurs lorsqu'ils doivent occasionnellement effectuer une action privilégiée, par exemple pour gérer un incident inattendu. Cela inclut par exemple de résoudre un problème dans un système de production ou de résoudre un problème impliquant des données sensibles.

Une façon de résoudre ce problème consiste à fournir un accès privilégié avec le juste-à-temps, c'est-à-dire à ne fournir un accès privilégié que si nécessaire. Une idée clé de la gestion des accès privilégiés avec le juste-à-temps consiste à distinguer l'accès permanent de l'accès éligible :

L'accès permanent s'applique jusqu'à ce que vous le révoquiez. Conformément au principe du moindre privilège, il est préférable de limiter l'accès permanent et de ne le fournir qu'aux quelques utilisateurs qui en ont besoin.
L'accès éligible ne s'applique pas immédiatement. Un utilisateur qui a été autorisé à accéder à un projet doit explicitement activer cet accès pour pouvoir accéder au projet. Il doit également motiver sa demande. Une fois l'accès de l'utilisateur activé, il expire automatiquement après une courte période.

La gestion des accès privilégiés avec le juste-à-temps peut vous aider à effectuer les opérations suivantes :

Réduire le risque qu'un utilisateur ne modifie ou ne supprime accidentellement des ressources. Par exemple, lorsque des utilisateurs ne disposent d'un accès privilégié que lorsque cela est nécessaire, cela les empêche d'exécuter à d'autres moments des scripts qui affectent involontairement des ressources qu'ils ne devraient pas pouvoir modifier.
Créer une piste d'audit qui indique pourquoi les privilèges ont été activés.
Effectuer des audits et des examens pour analyser les activités passées.

Utiliser l'accès avec le juste-à-temps pour mettre en œuvre un accès privilégié

L'accès avec le juste-à-temps est une application Open Source conçue pour s'exécuter sur App Engine ou Cloud Run et vous permet de mettre en œuvre un accès privilégié avec le juste-à-temps aux ressources Google Cloud. L'application permet aux administrateurs, aux utilisateurs et aux auditeurs d'effectuer les tâches suivantes :

Les administrateurs peuvent attribuer un rôle à un utilisateur ou à un groupe et le rendre éligible en ajoutant la condition IAM suivante :
```
has({}.jitAccessConstraint)
```
Les utilisateurs peuvent rechercher des projets et des rôles auxquels ils sont éligibles à l'aide de l'application d'accès avec le juste-à-temps.

La capture d'écran suivante, tirée de l'application d'accès avec le juste-à-temps, présente la liste des rôles auxquels un utilisateur est éligible dans un projet :

Il peut ensuite activer un ou plusieurs rôles, et fournir une justification pour en avoir l'accès :

Une fois qu'un utilisateur a activé un rôle, l'accès avec le juste-à-temps accorde à l'utilisateur un accès temporaire au projet.
Les auditeurs peuvent utiliser Cloud Logging pour savoir quand et pourquoi les rôles éligibles ont été activés par les utilisateurs.

Pour protéger l'application contre les accès non autorisés, l'application d'accès avec le juste-à-temps n'est accessible que via Identity-Aware Proxy (IAP). Avec IAP, un administrateur peut contrôler les utilisateurs autorisés à accéder à l'accès avec le juste-à-temps, et les conditions supplémentaires que ces utilisateurs doivent remplir pour obtenir l'accès.

Avant de commencer

Avant de déployer l'application d'accès avec le juste-à-temps, vous devez choisir la partie de votre hiérarchie de ressources pour laquelle vous souhaitez gérer l'accès privilégié avec le juste-à-temps. Vous pouvez gérer l'accès aux ressources suivantes :

Un seul projet
Un dossier contenant plusieurs projets
Tous les projets de votre organisation

Pour terminer le déploiement, vous avez besoin des éléments suivants :

Un accès super-administrateur au compte Cloud Identity ou Google Workspace correspondant à l'organisation Google Cloud que vous utilisez.
Autorisation de modifier la stratégie IAM du projet, du dossier ou de l'organisation que vous souhaitez gérer à l'aide d'un accès juste-à-temps.
Un deuxième utilisateur Cloud Identity ou Google Workspace que vous pouvez utiliser pour tester l'accès.

Vous devez également disposer d'un projet Google Cloud pour déployer l'application d'accès avec le juste-à-temps.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Déployer l'accès avec le juste-à-temps

Cette section explique comment déployer l'application d'accès avec le juste-à-temps sur App Engine ou Cloud Run.

Le déploiement de l'application d'accès avec le juste-à-temps sur Cloud Run nécessite une configuration plus complexe que le déploiement de l'application sur App Engine. Par conséquent, nous vous recommandons d'utiliser App Engine, sauf si vous effectuez le déploiement dans une région non compatible avec App Engine ou si vous ne pouvez pas utiliser App Engine pour d'autres raisons.

Le code de l'application d'accès avec le juste-à-temps se trouve dans un dépôt GitHub.

Dans cette section, nous partons du principe que vous êtes administrateur.

Configurer votre projet Google Cloud

Dans la console Google Cloud, basculez vers votre projet et activez les API requises:

App Engine

Activer les API Inventaire des éléments cloud, Resource Manager, Identity-Aware Proxy, Container Registry, Cloud Build, Identity and Access Management et Directory.
Activer les API

Cloud Run

Activer les API Inventaire des éléments cloud, Resource Manager, Identity-Aware Proxy, Container Registry, Cloud Run, Compute Engine, Identity and Access Management et Directory.
Activer les API
Ouvrez Cloud Shell.

Ouvrir Cloud Shell
Définissez une variable d'environnement pour contenir votre ID de projet :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par l'ID de votre projet.

Créez un compte de service pour l'application d'accès avec le juste-à-temps:

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

Autorisez l'application à créer des jetons à l'aide de son compte de service en lui attribuant le rôle Créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator) :
```
gcloud iam service-accounts add-iam-policy-binding $SERVICE_ACCOUNT \
  --member "serviceAccount:$SERVICE_ACCOUNT" \
  --role "roles/iam.serviceAccountTokenCreator"
```
L'application utilise l'autorisation pour créer des jetons afin d'accéder à l'API Directory et, éventuellement, de gérer les workflows d'approbation multipartite.

Accorder à l'application d'accès avec le juste-à-temps l'autorisation de gérer les liaisons IAM

Vous allez maintenant attribuer le rôle Administrateur de projet IAM au compte de service de l'application. Ce rôle permet à l'application d'accès avec le juste-à-temps de créer des liaisons IAM temporaires lorsqu'elle doit accorder un accès avec le juste-à-temps.

Comme le rôle Administrateur de projet IAM dispose de droits élevés, vous devez limiter l'accès au compte de service de l'application et au projet qui le contient.

Respectez les consignes suivantes :

Limitez le nombre d'utilisateurs pouvant accéder au projet et évitez d'attribuer le rôle Propriétaire ou Éditeur à un utilisateur.
Limitez le nombre d'utilisateurs autorisés à emprunter l'identité du compte de service. Les utilisateurs autorisés à emprunter l'identité de celui-ci incluent ceux qui ont le rôle Utilisateur du compte de service ou le rôle Créateur de jetons du compte de service.

Procédez comme suit pour attribuer le rôle Administrateur de projet IAM au compte de service :

Attribuez les rôles Administrateur de projet IAM (roles/resourcemanager.projectIamAdmin) et Lecteur d'éléments Cloud (roles/cloudasset.viewer) à la partie de votre hiérarchie de ressources pour laquelle vous souhaitez gérer l'accès privilégié en juste-à-temps :

Projet

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

Remplacez RESOURCE_PROJECT_ID par l'ID du projet Google Cloud pour lequel vous souhaitez gérer l'accès. Ce projet est différent de celui dans lequel vous déployez l'accès avec le juste-à-temps.

Dossier

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

Remplacez RESOURCE_FOLDER_ID par l'ID du dossier contenant les projets pour lesquels vous souhaitez gérer l'accès.

Organisation

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

Remplacez ORGANIZATION_ID par l'ID de votre organisation.

Accorder l'accès pour permettre à l'application de résoudre les adhésions aux groupes

L'application d'accès avec le juste-à-temps vous permet d'accorder un accès éligible à un utilisateur spécifique ou à un groupe entier. Pour évaluer les adhésions aux groupes, l'application doit être autorisée à lire les informations sur les adhésions aux groupes à partir de votre compte Cloud Identity ou Google Workspace.

Pour accorder au compte de service de l'application l'autorisation de lire les membres des groupes, procédez comme suit :

Ouvrez la console d'administration Google et connectez-vous en tant que super-administrateur.
Accédez à Compte > Rôles d'administrateur :

Accéder à "Rôles d'administrateur"
Cliquez sur Lecteur de groupes > Administrateurs.
Cliquez sur Attribuer des comptes de service.
Saisissez l'adresse e-mail suivante :
```
jitaccess@PROJECT_ID.iam.gserviceaccount.com
```
Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.
Cliquez sur Ajouter.
Cliquez sur Attribuer un rôle.

Rechercher le numéro client de votre compte Cloud Identity ou Google Workspace

Pour évaluer les adhésions à un groupe à l'aide de l'API Directory, l'application d'accès juste-à-temps doit disposer du numéro client de votre compte Cloud Identity ou Google Workspace. Procédez comme suit pour rechercher ce numéro :

Dans la console d'administration Google, accédez à Compte > Paramètres du compte :

Accéder à "Paramètres du compte"
Copiez le numéro client de votre compte. Le numéro client commence par C.

Vous en aurez besoin ultérieurement.
Fermez la console d'administration.

Déployer l'application

Vous êtes maintenant prêt à déployer l'application d'accès avec le juste-à-temps sur App Engine ou Cloud Run.

App Engine

Pour déployer l'application d'accès avec le juste-à-temps sur App Engine, procédez comme suit :

Dans Cloud Shell, définissez une variable d'environnement qui contiendra le numéro client de votre compte Cloud Identity ou Google Workspace :
```
ACCOUNT_CUSTOMER_ID=CUSTOMER_ID
```
Remplacez CUSTOMER_ID par le numéro client que vous avez recherché précédemment.
Créez une application App Engine :
```
gcloud app create --region LOCATION
```
Remplacez LOCATION par un emplacement App Engine compatible.

Clonez le dépôt GitHub et passez à la branche latest :

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

Créez un fichier de configuration pour l'application d'accès avec le juste-à-temps :

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

Dans ce fichier de configuration, vous pouvez personnaliser les valeurs des variables. Pour obtenir la liste des paramètres, consultez la page Options de configuration du dépôt GitHub associé.

Pour déployer l'application, procédez comme suit :
```
gcloud app deploy --appyaml app.yaml
```
Notez l'élément target url dans le résultat. Il s'agira de l'URL publique de l'application d'accès avec le juste-à-temps.

Si le message d'erreur NOT_FOUND: Unable to retrieve P4SA s'affiche, relancez la commande.

Cloud Run

Pour déployer l'application d'accès avec le juste-à-temps sur Cloud Run, procédez comme suit :

Dans Cloud Shell, définissez une variable d'environnement qui contiendra le numéro client de votre compte Cloud Identity ou Google Workspace :
```
ACCOUNT_CUSTOMER_ID=CUSTOMER_ID
```
Remplacez CUSTOMER_ID par le numéro client que vous avez recherché précédemment.
Sélectionnez une région dans laquelle effectuer le déploiement :
```
gcloud config set run/region REGION
```
Remplacez REGION par une région compatible avec Cloud Run.
Créez un service de backend :
```
gcloud compute backend-services create jitaccess-backend \
  --load-balancing-scheme=EXTERNAL \
  --global
```
Vous utiliserez ensuite ce service de backend pour configurer un équilibreur de charge et IAP.

Clonez le dépôt GitHub et passez à la branche latest :

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

Créez l'application et transférez l'image du conteneur vers 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

Créez un fichier de configuration pour l'application d'accès avec le juste-à-temps :

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

Dans ce fichier de configuration, vous pouvez personnaliser les valeurs des variables. Pour obtenir la liste des paramètres, consultez la page Options de configuration du dépôt GitHub associé.

Pour déployer l'application, procédez comme suit :
```
gcloud run services replace app.yaml
```

Configurer un équilibreur de charge

Vous allez maintenant configurer un équilibreur de charge pour l'application d'accès avec le juste-à-temps.

App Engine

App Engine configure automatiquement l'équilibreur de charge.

Cloud Run

Configurez un équilibreur de charge HTTPS pour votre service Cloud Run:

Réservez une adresse IP externe statique pour l'équilibreur de charge :
```
gcloud compute addresses create jitaccess-ip --global
```
Créez un certificat SSL géré pour l'équilibreur de charge :
```
gcloud compute ssl-certificates create jitaccess \
  --domains PUBLIC_FQDN \
  --global
```
où PUBLIC_FQDN correspond au nom de domaine complet public (FQDN) que vous souhaitez utiliser, par exemple jitaccess.example.com.

Recherchez l'adresse IP de l'équilibreur de charge :

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

Créez un enregistrement DNS A dans votre zone DNS publique qui pointe vers l'adresse IP de l'équilibreur de charge. Le nom complet de l'enregistrement DNS doit correspondre au nom que vous avez utilisé dans le certificat SSL.

Remarque : La propagation du nouvel enregistrement DNS peut prendre plusieurs minutes, voire plusieurs heures. Pendant ce temps, le certificat SSL géré ne peut pas encore être utilisé. Pour en savoir plus, consultez la page Résoudre les problèmes liés aux certificats gérés par Google.

Créez un groupe de points de terminaison du réseau sans serveur pour le service Cloud Run et connectez-le au service de 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)

Créez une interface d'équilibrage de charge qui utilise l'adresse IP externe et transfère le trafic vers le service de 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

Configurer Identity-Aware Proxy

Vous allez maintenant configurer IAP pour l'application d'accès avec le juste-à-temps.

Dans Cloud Shell, configurez un écran de consentement OAuth :

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

Dans la console Google Cloud, accédez à Sécurité >Identity-Aware Proxy.

Accéder à IAP
Définissez IAP sur activé.

Vous devez maintenant définir les utilisateurs autorisés à accéder à l'application d'accès avec le juste-à-temps. Vous pouvez accorder l'accès à des utilisateurs individuels, à des groupes ou à un domaine entier.

Dans Google Cloud Console, accédez à IAM et administration > IAM.

Accéder à IAM
Cliquez sur Accorder l'accès, puis définissez les valeurs suivantes:
1. Dans la liste des comptes principaux, sélectionnez un utilisateur, un groupe ou un domaine.
2. Dans la liste des rôles, sélectionnez Utilisateur de l'application Web sécurisée par IAP.
Le rôle Utilisateur de l'application Web sécurisée par IAP permet aux utilisateurs d'ouvrir l'application d'accès avec le juste-à-temps, mais il ne leur fournit pas encore d'accès à des ressources supplémentaires.
Cliquez sur Enregistrer.

L'application de la liaison de rôle peut prendre quelques minutes.

App Engine

La configuration IAP est maintenant terminée.

Cloud Run

Pour finaliser la configuration IAP, attribuez le rôle Demandeur Cloud Run (roles/run.invoker) à l'agent de service utilisé par 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"

Tester l'accès avec le juste-à-temps

Vous pouvez maintenant tester le processus d'attribution d'accès éligible et le processus d'utilisation de l'application d'accès avec le juste-à-temps pour activer l'accès éligible.

Accorder un accès éligible

Pour commencer, vous devez accorder l'accès éligible à un deuxième utilisateur Cloud Identity ou Google Workspace.

Dans la liste des projets de la console Google Cloud, sélectionnez un projet faisant partie de la hiérarchie des ressources gérée par l'application d'accès avec le juste-à-temps.
Sur la page IAM, cliquez sur Accorder l'accès.
Saisissez l'adresse e-mail de votre deuxième utilisateur Cloud Identity ou Google Workspace et sélectionnez un rôle, tel que Projet > Navigateur.
Cliquez sur Ajouter une condition :
Saisissez un titre, tel que Eligible for JIT access.
Sélectionnez Éditeur de conditions, puis saisissez l'expression CEL suivante :
```
has({}.jitAccessConstraint)
```
Enregistrez les modifications.

Activer l'accès

Vous pouvez maintenant changer d'utilisateur et demander un accès temporaire à une ressource.

Ouvrez une fenêtre de navigation privée et accédez à l'URL de l'application d'accès avec le juste-à-temps que vous avez notée précédemment.
Connectez-vous en tant que l'utilisateur auquel vous avez accordé un accès éligible.
Dans l'application d'accès avec le juste-à-temps, sélectionnez un rôle et une ressource pour lesquels vous souhaitez activer l'accès.
Saisissez une justification telle que testing, puis cliquez sur Demander l'accès.

Sur la page suivante, vous pouvez remarquer que votre accès a été temporairement activé.

Analyser des journaux

Vous pouvez maintenant revenir à l'utilisateur avec accès administrateur et consulter le journal.

Dans la console Google Cloud, accédez à Logging > Explorateur de journaux.

Accéder à l'explorateur de journaux
Définissez Afficher la requête sur activé.
Saisissez la requête suivante :
```
labels.event="api.activateRole"
```

Cliquez sur Exécuter la requête.

Le résultat ressemble à ce qui suit :

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

Notez qu'un enregistrement de journal a été créé pour chaque rôle que vous avez activé. L'enregistrement de journal inclut un ensemble de libellés que vous pouvez utiliser pour créer des filtres personnalisés.

Mettre à niveau l'accès avec le juste-à-temps

Cette section explique comment mettre à niveau un déploiement d'accès avec le juste-à-temps pour utiliser une version plus récente de l'application ou une autre configuration.

Dans cette section, nous partons du principe que vous êtes administrateur.

Dans la console Google Cloud, basculez vers votre projet, puis ouvrez Cloud Shell.

Ouvrir Cloud Shell
Définissez une variable d'environnement pour contenir votre ID de projet :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par l'ID de votre projet.

Clonez le dépôt GitHub et passez à la branche latest :

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

Téléchargez le fichier de configuration que vous avez utilisé précédemment pour déployer l'application et enregistrez-le dans un fichier 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

Si le téléchargement du fichier app.yaml échoue, vous pouvez télécharger votre configuration actuelle dans la console Google Cloud.

Cloud Run

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

Remplacez REGION par la région qui contient votre déploiement Cloud Run existant.

Si vous souhaitez modifier votre configuration, modifiez le fichier app.yaml. Pour obtenir la liste des paramètres, consultez la page Options de configuration du dépôt GitHub associé.

Pour déployer l'application, procédez comme suit :

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

Étapes suivantes

Configurer l'approbation multipartie
Découvrez comment utiliser l'accès contextuel pour sécuriser l'accès à l'application d'accès avec le juste-à-temps.
Apprenez-en plus sur les conditions IAM.
Configurez un domaine personnalisé pour l'application d'accès avec le juste-à-temps.
Pour découvrir d'autres architectures de référence, schémas et bonnes pratiques, consultez le Centre d'architecture cloud.