Just-in-Time-privilegierten Zugriff auf Projekte verwalten

Last reviewed 2024-01-04 UTC

In diesem Dokument wird beschrieben, wie Sie mit einem Open-Source-Tool den privilegierten Zugriff auf Google Cloud-Projekte in einem bestimmten Zeitraum implementieren. Mit dem privilegierten Zugriff mit Just-in-Time-Berechtigung können Sie einer begrenzten Anzahl von Nutzern nur vorübergehend Zugriff auf Projekte gewähren, wenn dies erforderlich ist.

Das Dokument richtet sich an Administratoren, die den Nutzerzugriff auf Google Cloud-Ressourcen verwalten. Dabei wird davon ausgegangen, dass Sie mit Google Cloud, Identity and Access Management (IAM) und zugehörigen Konzepten vertraut sind.

Just-in-Time-Zugriffsverwaltung – Übersicht

Wenn Sie das Prinzip der geringsten Berechtigung befolgen, gewähren Sie Nutzern nur so viel Zugriff, dass sie tägliche Aktivitäten ausführen, aber nichts weiter tun können. Wenn Sie dieses Prinzip befolgen, können Sie das Risiko reduzieren. Dies kann jedoch bei Nutzern schwierig sein, wenn sie gelegentlich eine privilegierte Aktion ausführen müssen, z. B. um einen unerwarteten Vorfall zu bewältigen. Beispiele: Fehlerbehebung für ein Problem in einem Produktionssystem oder Fehlerbehebung für ein Problem mit sensiblen Daten.

Eine Möglichkeit, dieses Problem zu beheben, besteht darin, Just-in-Time-Zugriff zu gewähren, also nur bei Bedarf zu gewähren. Eine wichtige Idee der Just-in-Time-Zugriffsverwaltung besteht darin, zwischen permanentem Zugriff und zulässigem Zugriff zu unterscheiden:

Der dauerhafte Zugriff gilt, bis Sie ihn widerrufen. Nach dem Prinzip der geringsten Berechtigung ist es am besten, den permanenten Zugriff einzuschränken und ihn nur den wenigen Nutzern zur Verfügung zu stellen, die ihn benötigen.
Zulässige Zugriffe gelten nicht sofort. Stattdessen muss ein Nutzer, dem Zugriff auf ein Projekt gewährt wurde, diesen Zugriff explizit aktivieren, bevor er auf das Projekt zugreifen kann. Sie müssen auch eine Begründung dafür angeben. Nachdem der Zugriff des Nutzers aktiviert wurde, läuft der Zugriff automatisch nach kurzer Zeit ab.

Mit der Just-in-Time-Zugriffsverwaltung können Sie folgende Aufgaben ausführen:

Reduzieren Sie das Risiko, dass jemand versehentlich Ressourcen ändert oder löscht. Wenn Nutzer beispielsweise nur bei Bedarf einen privilegierten Zugriff haben, können sie Skripts nicht zu anderen Zeiten ausführen, die unbeabsichtigt Ressourcen betreffen, die nicht geändert werden dürfen.
Erstellen Sie einen Audit-Trail, der angibt, warum Berechtigungen aktiviert wurden.
Führen Sie Audits und Überprüfungen durch, um frühere Aktivitäten zu analysieren.

Nutzen Sie den Just-in-Time-Zugriff, um privilegierten Zugriff zu implementieren

Just-In-Time-Zugriff ist eine Open-Source-Anwendung, die in App Engine oder Cloud Run ausgeführt werden kann und mit der Sie Just-in-Time-Zugriff auf Google Cloud-Ressourcen implementieren können. Mit der Anwendung können Administratoren, Nutzer und Prüfer die folgenden Aufgaben ausführen:

Administratoren können einem Nutzer oder einer Gruppe eine Rolle zuweisen und die Rolle als Rolle hinzufügen, indem sie die folgende IAM-Bedingung hinzufügen:
```
has({}.jitAccessConstraint)
```
Nutzer können mithilfe der Zugriffs-Anwendung "Just-In-Time" nach Projekten und Rollen suchen, auf die sie Zugriff haben.

Der folgende Screenshot der Just-In-Time-Zugriffs-Anwendung zeigt eine Liste der Rollen, für die ein Nutzer in einem Projekt berechtigt ist:

Nutzer können dann eine oder mehrere Rollen aktivieren und eine Begründung für den Zugriff angeben:

Nachdem ein Nutzer eine Rolle aktiviert hat, gewährt Just-In-Time-Zugriff dem Nutzer vorübergehend Zugriff auf das Projekt.
Auditoren können mit Cloud Logging prüfen, wann und warum berechtigte Rollen von Nutzern aktiviert wurden.

Zum Schutz der Anwendung vor unbefugtem Zugriff kann nur auf die Just-in-Time-Zugriffsanwendung über Identity-Aware Proxy (IAP) zugegriffen werden. Mit IAP kann ein Administrator steuern, welche Nutzer auf Just-In-Time-Zugriff zugreifen dürfen und welche zusätzlichen Bedingungen diese Nutzer erfüllen müssen, um Zugriff zu erhalten.

Hinweis

Bevor Sie die Just-in-Time-Zugriffsanwendung bereitstellen, müssen Sie entscheiden, für welchen Teil Ihrer Ressourcenhierarchie der Just-in-Time-Zugriff gewährt werden soll. Sie können den Zugriff für die folgenden Ressourcen verwalten:

Ein einzelnes Projekt
Einen Ordner mit mehreren Projekten
Alle Projekte in Ihrer Organisation

Für das Deployment benötigen Sie Folgendes:

Super Admin-Zugriff auf das Cloud Identity- oder Google Workspace-Konto, das der von Ihnen verwendeten Google Cloud-Organisation entspricht.
Eine Berechtigung zum Ändern der IAM-Richtlinie des Projekts, des Ordners oder der Organisation, die Sie mit Just-In-Time-Zugriff verwalten möchten.
Einen zweiten Cloud Identity- oder Google Workspace-Nutzer, mit dem Sie den Zugriff testen können.

Sie benötigen außerdem ein Google Cloud-Projekt, um die Anwendung „Just-In-Time Access“ bereitzustellen.

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

Go to project selector
Make sure that billing is enabled for your Google Cloud project.

Just-in-Time-Zugriff bereitstellen

In diesem Abschnitt wird beschrieben, wie Sie die Just-In-Time-Zugriffsanwendung in App Engine oder Cloud Run bereitstellen.

Die Bereitstellung der Just-In-Time-Zugriffsanwendung in Cloud Run erfordert eine komplexere Konfiguration als die Bereitstellung der Anwendung in App Engine. Wir empfehlen daher, App Engine zu verwenden, es sei denn, Sie stellen die Bereitstellung in einer Region bereit, die App Engine nicht unterstützt, oder wenn Sie App Engine aus anderen Gründen nicht verwenden können.

Der Code für Just-In-Time-Zugriff befindet sich in einem GitHub-Repository.

In diesem Abschnitt wird davon ausgegangen, dass Sie ein Administrator sind.

Konfigurieren Sie Ihr Google Cloud-Projekt.

Wechseln Sie in der Google Cloud Console zu Ihrem Projekt und aktivieren Sie die erforderlichen APIs:

App Engine

Enable the Cloud Asset Inventory, Resource Manager, Identity-Aware Proxy, Container Registry, Cloud Build, Identitäts- und Zugriffsverwaltung und Verzeichnis APIs.
Enable the APIs

Cloud Run

Enable the Cloud Asset Inventory, Resource Manager, Identity-Aware Proxy, Container Registry, Cloud Run, Compute Engine, Identitäts- und Zugriffsverwaltung und Verzeichnis APIs.
Enable the APIs
Öffnen Sie Cloud Shell.

Cloud Shell öffnen
Legen Sie eine Umgebungsvariable für Ihre Projekt-ID fest:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch die ID Ihres Projekts.

Erstellen Sie ein Dienstkonto für die Anwendung "Just-in-Time Access":

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

Erlauben Sie der Anwendung, mithilfe ihres Dienstkontos Tokens zu erstellen. Weisen Sie dafür die Rolle Ersteller von Dienstkonto-Tokens (roles/iam.serviceAccountTokenCreator) zu:
```
gcloud iam service-accounts add-iam-policy-binding $SERVICE_ACCOUNT \
  --member "serviceAccount:$SERVICE_ACCOUNT" \
  --role "roles/iam.serviceAccountTokenCreator"
```
Die Anwendung verwendet die Berechtigung zum Erstellen von Tokens für den Zugriff auf die Directory API und optional zur Verarbeitung von Genehmigungsworkflows durch mehrere Parteien.

Dem Just-in-Time Access Zugriff zur Verwaltung von IAM-Bindungen gewähren

Sie erteilen dem Dienstkonto der Anwendung nun die Rolle Projekt-IAM-Administrator. Mit dieser Rolle kann die Just-In-Time-Zugriffsanwendung temporäre IAM-Bindungen erstellen, wenn sie Just-in-Time-Zugriff gewähren muss.

Da die Rolle Project IAM Admin stark privilegiert ist, müssen Sie den Zugriff auf das Dienstkonto der Anwendung und auf das Projekt beschränken, das sie enthält.

Beachten Sie folgende Richtlinien:

Begrenzen Sie die Anzahl der Nutzer, die auf das Projekt zugreifen können, und gewähren Sie keinem Nutzer die Rolle Inhaber oder Bearbeiter.
Schränken Sie die Anzahl der Nutzer ein, die die Identität des Dienstkontos übernehmen können. Zu den Nutzern, die diese Identität übernehmen sollten, gehören die Nutzer mit der Rolle Dienstkontonutzer oder Ersteller von Dienstkonto-Token.

So weisen Sie dem Dienstkonto die Rolle Project IAM Admin zu:

Gewähren Sie die Rolle Project IAM Admin (roles/resourcemanager.projectIamAdmin) und die Rolle Cloud Asset Viewer (roles/cloudasset.viewer) für den Teil Ihrer Ressourcenhierarchie, für den Sie den privilegierten Just-in-Time-Zugriff verwalten möchten:

Projekt

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

Ersetzen Sie RESOURCE_PROJECT_ID durch die ID des Google Cloud-Projekts, für das Sie den Zugriff verwalten möchten. Dieses Projekt unterscheidet sich von dem Projekt, für das Sie den Just-In-Time-Zugriff bereitstellen.

Ordner

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

Ersetzen Sie RESOURCE_FOLDER_ID durch die ID des Ordners, der die Projekte enthält, für die Sie den Zugriff verwalten möchten.

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

Ersetzen Sie ORGANIZATION_ID durch die ID Ihrer Organisation.

Gewähren Sie der Anwendung Zugriff, um Gruppenmitgliedschaften aufzulösen

Mit der Anwendung "Just-In-Time Access" können Sie einem bestimmten Nutzer oder einer gesamten Gruppe zulässigen Zugriff gewähren. Zum Bewerten der Gruppenmitgliedschaft muss die Anwendung Informationen zur Gruppenmitgliedschaft aus Ihrem Cloud Identity- oder Google Workspace-Konto lesen können.

So gewähren Sie dem Dienstkonto der Anwendung Zugriffsberechtigungen zum Lesen von Gruppenmitgliedschaften:

Öffnen Sie die Google Workspace-Admin-Konsole und melden Sie sich als Super Admin-Nutzer an.
Klicken Sie auf Konto > Administratorrollen.

Gehen Sie zu Admin-Rollen
Klicken Sie auf Gruppenleser > Administratoren.
Klicken Sie auf Dienstkonten zuweisen.
Geben Sie die folgende E-Mail-Adresse ein:
```
jitaccess@PROJECT_ID.iam.gserviceaccount.com
```
Ersetzen Sie PROJECT_ID durch die ID Ihres Google Cloud-Projekts.
Klicken Sie auf Add (Hinzufügen).
Klicken Sie auf Rolle zuweisen.

Kundennummer Ihres Cloud Identity- oder Google Workspace-Kontos ermitteln

Wenn Sie Gruppenmitgliedschaften mithilfe der Directory API auswerten möchten, benötigt die Just-In-Time-Zugriffsanwendung die Kundennummer Ihres Cloud Identity oder Google Workspace-Kontos. So rufen Sie diese ID ab:

Klicken Sie in der Admin-Konsole auf Konto > Kontoeinstellungen:

Kontoeinstellungen aufrufen
Kopieren Sie die Kundennummer Ihres Kontos. Die Kundennummer beginnt mit C.

Sie benötigen die Kundennummer in einem späteren Schritt.
Schließen Sie die Admin-Konsole.

Anwendung bereitstellen

Jetzt können Sie die Just-In-Time-Access-Anwendung in App Engine oder Cloud Run bereitstellen.

App Engine

Führen Sie die folgenden Schritte aus, um die Just-In-Time-Access-Anwendung in App Engine bereitzustellen.

Legen Sie in Cloud Shell eine Umgebungsvariable für die Kundennummer Ihres Cloud Identity- oder Google Workspace-Kontos fest:
```
ACCOUNT_CUSTOMER_ID=CUSTOMER_ID
```
Ersetzen Sie CUSTOMER_ID durch die Kundennummer, die Sie zuvor gesucht haben.
Erstellen Sie eine App Engine-Anwendung:
```
gcloud app create --region LOCATION
```
Ersetzen Sie LOCATION durch einen unterstützten App Engine-Speicherort.

Klonen Sie das GitHub-Repository und wechseln Sie zum Zweig latest:

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

Erstellen Sie eine Konfigurationsdatei für die Anwendung "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 dieser Konfigurationsdatei können Sie die Werte der Variablen anpassen. Eine Liste der Einstellungen finden Sie auf der Seite Konfiguration im zugehörigen GitHub-Repository.

Stellen Sie die Anwendung bereit:
```
gcloud app deploy --appyaml app.yaml
```
Notieren Sie sich den target url in der Ausgabe. Dies ist die öffentliche URL der Just-in-Time-Zugriffsanwendung.

Wiederholen Sie den Befehl, wenn die Fehlermeldung NOT_FOUND: Unable to retrieve P4SA angezeigt wird.

Cloud Run

Führen Sie die folgenden Schritte aus, um die Just-In-Time-Access-Anwendung in Cloud Run bereitzustellen.

Legen Sie in Cloud Shell eine Umgebungsvariable für die Kundennummer Ihres Cloud Identity- oder Google Workspace-Kontos fest:
```
ACCOUNT_CUSTOMER_ID=CUSTOMER_ID
```
Ersetzen Sie CUSTOMER_ID durch die Kundennummer, die Sie zuvor gesucht haben.
Wählen Sie eine Region für die Bereitstellung aus:
```
gcloud config set run/region REGION
```
Ersetzen Sie REGION durch eine Region, die Cloud Run unterstützt.
Erstellen Sie einen Backend-Dienst:
```
gcloud compute backend-services create jitaccess-backend \
  --load-balancing-scheme=EXTERNAL \
  --global
```
Sie verwenden diesen Backend-Dienst später, um einen Load-Balancer und IAP zu konfigurieren.

Klonen Sie das GitHub-Repository und wechseln Sie zum Zweig latest:

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

Erstellen Sie die Anwendung und übertragen Sie das Container-Image per Push an 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

Erstellen Sie eine Konfigurationsdatei für die Anwendung "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 dieser Konfigurationsdatei können Sie die Werte der Variablen anpassen. Eine Liste der Einstellungen finden Sie auf der Seite Konfiguration im zugehörigen GitHub-Repository.

Stellen Sie die Anwendung bereit:
```
gcloud run services replace app.yaml
```

Load-Balancer konfigurieren

Konfigurieren Sie nun einen Load-Balancer für die Anwendung "Just-In-Time Access".

App Engine

App Engine konfiguriert den Load-Balancer automatisch.

Cloud Run

Konfigurieren Sie einen HTTPS-Load-Balancer für den Cloud Run-Dienst:

Reservieren Sie eine statische externe IP-Adresse für den Load-Balancer:
```
gcloud compute addresses create jitaccess-ip --global
```
Erstellen Sie ein verwaltetes SSL-Zertifikat für den Load-Balancer:
```
gcloud compute ssl-certificates create jitaccess \
  --domains PUBLIC_FQDN \
  --global
```
Dabei ist PUBLIC_FQDN der öffentliche, vollständig qualifizierte Domainname (FQDN), den Sie verwenden möchten, z. B. jitaccess.example.com.

Suchen Sie die IP-Adresse des Load-Balancers:

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

Erstellen Sie einen DNS-A-Eintrag in Ihrer öffentlichen DNS-Zone, der auf die IP-Adresse des Load-Balancers verweist. Der vollständig qualifizierte Name des DNS-Eintrags muss mit dem Namen übereinstimmen, den Sie für das SSL-Zertifikat verwendet haben.

Hinweis: Es kann einige Minuten oder Stunden dauern, bis der neue DNS-Eintrag verbreitet wurde. Während dieser Zeit kann das verwaltete SSL-Zertifikat nicht verwendet werden. Weitere Informationen finden Sie unter Fehlerbehebung bei von Google verwalteten Zertifikaten.

Erstellen Sie eine serverlose Netzwerk-Endpunktgruppe für den Cloud Run-Dienst und verbinden Sie sie mit dem Backend-Dienst:

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)

Erstellen Sie ein Frontend des Load-Balancers, das die externe IP-Adresse verwendet und den Traffic an den Backend-Dienst weiterleitet:

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

Identity-Aware Proxy konfigurieren

Konfigurieren Sie IAP für die Anwendung "Just-in-Time Access".

Konfigurieren Sie in Cloud Shell einen OAuth-Zustimmungsbildschirm:

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

Wechseln Sie in der Google Cloud Console zu Sicherheit> Identity-Aware Proxy:

Zu IAP
Setzen Sie IAP auf aktiviert.

Sie müssen nun festlegen, welche Nutzer auf die Just-In-Time-Zugriffsanwendung zugreifen dürfen. Sie können einzelnen Nutzern, Gruppen oder einer gesamten Domain Zugriff gewähren.

Wechseln Sie in der Google Cloud Console zu IAM und Verwaltung > IAM.

IAM aufrufen
Klicken Sie auf Zugriff erlauben und legen Sie dann die folgenden Werte fest:
1. Wählen Sie in der Liste der Hauptkonten einen Nutzer, eine Gruppe oder eine Domain aus.
2. Wählen Sie in der Rollenliste den Nutzer IAP-gesicherte Webanwendung aus.
Mit der Rolle Nutzer von IAP-gesicherten Web-Apps können Nutzer die Anwendung "Just-In-Time Access" öffnen, aber noch nicht auf zusätzliche Ressourcen zugreifen.
Klicken Sie auf Speichern.

Es kann einige Minuten dauern, bis die Rollenbindung wirksam wird.

App Engine

Die IAP-Konfiguration ist jetzt abgeschlossen.

Cloud Run

Zum Abschließen der IAP-Konfiguration weisen Sie dem Dienst-Agent, der von IAP verwendet wird, die Rolle Cloud Run Invoker (roles/run.invoker) zu:

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"

Just-in-Time-Zugriff testen

Sie können jetzt den Prozess testen, wie Sie berechtigten Zugriff gewähren und die Verwendung der Zugriffs-Anwendung "Just-In-Time" zur Aktivierung berechtigten Zugriffs testen.

Berechtigten Zugriff gewähren

Als Erstes gewähren Sie einem zweiten Cloud Identity- oder Google Workspace-Nutzer zulässigen Zugriff.

Verwenden Sie in der Google Cloud Console die Projektliste, um ein Projekt auszuwählen, das Teil der Ressourcenhierarchie ist, die von der Just-in-Time-Zugriffsanwendung verwaltet wird.
Klicken Sie auf der IAM-Seite auf Zugriff erlauben.
Geben Sie die E-Mail-Adresse des zweiten Cloud Identity- oder Google Workspace-Nutzers ein und wählen Sie eine Rolle aus, z. B. Projekt > Browser.
Klicken Sie auf Bedingung hinzufügen.
Geben Sie einen Titel ein, z. B. Eligible for JIT access.
Wählen Sie Bedingungseditor aus und geben Sie den folgenden CEL-Ausdruck ein:
```
has({}.jitAccessConstraint)
```
Speichern Sie die Änderungen.

Zugriff aktivieren

Jetzt können Sie die Nutzer wechseln und den temporären Zugriff auf eine Ressource anfordern.

Öffnen Sie ein Inkognitofenster im Browser und rufen Sie die URL der Anwendung "Just-in-Time Access" auf, die Sie zuvor notiert haben.
Melden Sie sich als Nutzer an, dem Sie Zugriff gewährt haben.
Wählen Sie in der Anwendung "Just-In-Time Access" eine Rolle und Ressource aus, für die Sie den Zugriff aktivieren möchten.
Geben Sie eine Begründung wie testing ein und klicken Sie dann auf Zugriff anfordern.

Beachten Sie auf der nächsten Seite, dass Ihr Zugriff vorübergehend aktiviert wurde.

Logs analysieren

Sie können jetzt zu Ihrem Administrator zurückkehren und das Log überprüfen.

Wechseln Sie in der Google Cloud Console zu Logging > Log-Explorer.

Zum Log-Explorer
Legen Sie Abfrage anzeigen auf Aktiviert fest.
Geben Sie die folgende Abfrage ein:
```
labels.event="api.activateRole"
```

Klicken Sie auf Abfrage ausführen.

Die Ausgabe sieht etwa so aus:

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

Beachten Sie, dass für jede aktivierte Rolle ein Logeintrag erstellt wurde. Der Logdatensatz enthält eine Reihe von Labels, mit denen Sie benutzerdefinierte Filter erstellen können.

Just-In-Time-Zugriff upgraden

In diesem Abschnitt wird beschrieben, wie Sie ein vorhandenes Just-In-Time-Zugriffs-Deployment upgraden, um eine neuere Version der Anwendung zu verwenden oder eine andere Konfiguration zu verwenden.

In diesem Abschnitt wird davon ausgegangen, dass Sie ein Administrator sind.

Wechseln Sie in der Google Cloud Console zu Ihrem Projekt und öffnen Sie Cloud Shell.

Cloud Shell öffnen
Legen Sie eine Umgebungsvariable für Ihre Projekt-ID fest:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch die ID Ihres Projekts.

Klonen Sie das GitHub-Repository und wechseln Sie zum Zweig latest:

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

Laden Sie die Konfigurationsdatei herunter, die Sie zuvor zum Bereitstellen der Anwendung verwendet haben, und speichern Sie sie in der Datei 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

Wenn das Herunterladen der Datei app.yaml fehlschlägt, können Sie Ihre aktuelle Konfiguration in der Google Cloud Console herunterladen.

Cloud Run

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

Ersetzen Sie REGION durch die Region, die die vorhandene Cloud Run-Bereitstellung enthält.

Wenn Sie Änderungen an Ihrer Konfiguration vornehmen möchten, bearbeiten Sie die Datei app.yaml. Eine Liste der Einstellungen finden Sie auf der Seite Konfiguration im zugehörigen GitHub-Repository.

Stellen Sie die Anwendung bereit:

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

Nächste Schritte

Konfigurieren Sie die Genehmigung mehrerer Parteien.
Erfahren Sie, wie Sie den kontextsensitiven Zugriff für den sicheren Zugriff auf Just-In-Time-Zugriff verwenden können.
Weitere Informationen zu IAM-Bedingungen
Benutzerdefinierte Domain für die Anwendung "Just-In-Time Access" konfigurieren
Weitere Referenzarchitekturen, Diagramme und Best Practices finden Sie im Cloud-Architekturcenter.