Gerenciar o acesso privilegiado just-in-time e imediato aos projetos

Last reviewed 2024-07-22 UTC

Neste documento, descrevemos como usar uma ferramenta de código aberto para implementar o acesso privilegiado just-in-time aos projetos do Google Cloud. O acesso privilegiado just-in-time permite que você conceda acesso temporário a projetos para um conjunto limitado de usuários somente quando o acesso for necessário.

O documento é para administradores que gerenciam o acesso dos usuários aos recursos do Google Cloud. Ele pressupõe que você esteja familiarizado com o Google Cloud, o Identity and Access Management (IAM) e os conceitos relacionados.

Visão geral do gerenciamento de acesso com privilégios just-in-time

Ao seguir o princípio do menor privilégio, você concede aos usuários acesso suficiente para que eles possam realizar atividades cotidianas, mas não podem fazer mais nada. Seguir esse princípio ajuda a reduzir riscos. No entanto, isso pode gerar atrito quando os usuários precisarem realizar uma ação privilegiada, por exemplo, para lidar com um incidente inesperado. Exemplos: solucionar um problema em um sistema de produção ou solucionar um problema que envolva dados confidenciais.

Uma maneira de resolver esse problema é fornecer acesso privilegiado no momento certo, ou seja, conceder acesso privilegiado somente quando necessário. Uma ideia importante do gerenciamento de acesso com privilégios just-in-time é distinguir entre acesso permanente e acesso qualificado:

O acesso permanente será aplicado até que seja revogado. Seguindo o princípio do menor privilégio, é melhor limitar o acesso permanente e fornecê-lo apenas aos poucos usuários que precisam dele.
O acesso qualificado não será aplicado imediatamente. Em vez disso, o usuário que tiver acesso qualificado a um projeto precisará ativá-lo explicitamente para poder acessá-lo. Elas também precisam fornecer uma justificativa para isso. Depois da ativação, o acesso do usuário expira automaticamente após um curto período.

O uso do gerenciamento de acesso privilegiado just-in-time pode ajudar você a fazer o seguinte:

Reduza o risco de alguém modificar ou excluir recursos acidentalmente. Por exemplo, quando os usuários têm acesso privilegiado apenas quando necessário, ela ajuda a impedir que eles executem scripts em outros momentos que afetam acidentalmente os recursos que eles não poderiam alterar.
Criar uma trilha de auditoria que indique por que os privilégios foram ativados
Fazer auditorias e análises para analisar atividades anteriores

Use o acesso just-in-time para implementar o acesso privilegiado

O acesso just-in-time é um aplicativo de código aberto projetado para ser executado no App Engine ou Cloud Run e permite que você implemente o acesso privilegiado just-in-time aos recursos do Google Cloud. Com o aplicativo, administradores, usuários e auditores podem realizar as seguintes tarefas:

Os administradores podem conceder um papel a um usuário ou grupo e tornar o papel qualificado adicionando a seguinte condição do IAM:
```
has({}.jitAccessConstraint)
```
Usuários podem pesquisar projetos e papéis que eles estão qualificados para acessar usando o aplicativo de acesso just-in-time.

A captura de tela a seguir do aplicativo Just-In-Time Access mostra uma lista de papéis para os quais um usuário está qualificado em um projeto:

É possível ativar um ou mais papéis e fornecer uma justificativa para ter acesso:

Depois que o usuário ativa um papel, o acesso just-in-time concede ao usuário acesso temporário ao projeto.
Os auditores podem usar o Cloud Logging para analisar quando e por que os papéis qualificados foram ativados pelos usuários.

Para proteger o aplicativo contra acesso não autorizado, o aplicativo Just-In-Time Access só pode ser acessado pelo Identity-Aware Proxy (IAP). Usando o IAP, um administrador pode controlar quais usuários têm permissão para acessar o acesso just-in-time e quais condições adicionais esses usuários precisam atender para ter acesso. de dados.

Antes de começar

Antes de implantar o aplicativo de Just-In-Time Access, você precisa decidir para qual parte da hierarquia de recursos quer gerenciar o acesso privilegiado just-in-time. Você pode gerenciar o acesso para os seguintes recursos:

Um único projeto
Uma pasta que contém vários projetos
Todos os projetos da sua organização

Para concluir a implantação, você precisa do seguinte:

Acesso de superadministrador à conta do Cloud Identity ou do Google Workspace que corresponde à organização do Google Cloud que você está usando.
Permissão para modificar a política do IAM do projeto, da pasta ou da organização que você quer gerenciar usando o acesso just-in-time.
Um segundo usuário do Cloud Identity ou do Google Workspace que pode ser usado para testar o acesso.

Você também precisa de um projeto do Google Cloud para implantar o aplicativo Just-In-Time Access.

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

Go to project selector

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Implantar o acesso just-in-time

Nesta seção, descrevemos como implantar o aplicativo de acesso just-in-time no App Engine ou no Cloud Run.

A implantação do aplicativo de acesso just-in-time no Cloud Run requer uma configuração mais complexa do que a implantação do aplicativo no App Engine. Portanto, recomendamos que você use o App Engine, a menos que esteja implantando em uma região que não seja compatível com o App Engine, ou se não for possível usar o App Engine por outros motivos.

O código do acesso just-in-time está em um repositório do GitHub.

Esta seção pressupõe que você é um administrador.

Configurar o projeto do Google Cloud

No console do Google Cloud, alterne para o projeto e ative as APIs necessárias:

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
Abra o Cloud Shell.

Abrir o Cloud Shell
Defina uma variável de ambiente que contenha o ID do projeto:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo ID do seu projeto.

Crie uma conta de serviço para o aplicativo Just-in-Time Access:

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

Conceda ao aplicativo o papel de Criador de token da conta de serviço (roles/iam.serviceAccountTokenCreator) para permitir que ele crie tokens usando a própria conta de serviço:
```
gcloud iam service-accounts add-iam-policy-binding $SERVICE_ACCOUNT \
  --member "serviceAccount:$SERVICE_ACCOUNT" \
  --role "roles/iam.serviceAccountTokenCreator"
```
O aplicativo usa a permissão para criar tokens para acessar a API Directory e, opcionalmente, para processar fluxos de trabalho de aprovação de várias partes.

Conceder permissão ao aplicativo Just-in-Time Access para gerenciar vinculações do IAM

Agora você concede o papel Administrador do IAM do projeto à conta de serviço do aplicativo. Esse papel permite que o aplicativo Just-In-Time Access crie vinculações temporárias do IAM quando ele precisa conceder acesso just-in-time.

Como o papel Administrador do projeto de IAM é altamente privilegiado, você precisa limitar o acesso à conta de serviço do aplicativo e ao projeto que a contém.

Siga estas diretrizes:

Limite o número de usuários que podem acessar o projeto e evite conceder a qualquer usuário o papel de Proprietário ou de Editor.
Limite o número de usuários que podem representar a conta de serviço. Os usuários que podem fazer essa representação incluem aqueles que têm o papel usuário da conta de serviço ou criador do token da conta de serviço.

Para conceder o papel Administrador do IAM do projeto à conta de serviço, faça o seguinte:

Conceda o papel Administrador de projeto do IAM (roles/resourcemanager.projectIamAdmin) e o papel Visualizador do recurso do Cloud (roles/cloudasset.viewer) à parte da sua hierarquia de recursos que você quer gerenciar o acesso privilegiado just-in-time para:

Projeto

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

Substitua RESOURCE_PROJECT_ID pelo ID do projeto do Google Cloud em que você quer gerenciar o acesso. Esse projeto é diferente daquele em que você está implantando o acesso just-in-time.

Pasta

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

Substitua RESOURCE_FOLDER_ID pelo ID da pasta que contém os projetos em que você quer gerenciar o acesso.

Organização

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

Substitua ORGANIZATION_ID pelo ID da organização.

Permitir acesso para permitir que o aplicativo resolva associações ao grupo

Com o aplicativo Just-In-Time Access, você concede acesso qualificado a um usuário específico ou a um grupo inteiro. Para avaliar as associações a grupos, o aplicativo precisa ter permissão para ler as informações de associação a grupos da sua conta do Cloud Identity ou do Google Workspace.

Para conceder permissão à conta de serviço do aplicativo para ler associações a grupos, faça o seguinte:

Abra o Google Admin Console e faça login como usuário superadministrador.
Acesse Conta > Papéis do administrador:

Acesse Funções do administrador
Clique em Leitor de grupos > Administradores.
Clique em Atribuir contas de serviço.
Digite o seguinte endereço de e-mail:
```
jitaccess@PROJECT_ID.iam.gserviceaccount.com
```
Substitua PROJECT_ID pelo ID do projeto do Google Cloud.
Clique em Adicionar.
Clique em Atribuir papel.

Pesquisar o ID de cliente da sua conta do Cloud Identity ou do Google Workspace

Para avaliar as associações a grupos usando a API Directory, o aplicativo de acesso Just-In-Time precisa do ID de cliente da sua conta do Cloud Identity ou do Google Workspace. Para procurar esse ID, faça o seguinte:

No Google Admin Console, acesse Conta > Configurações da conta:

Acessar as configurações da conta
Copie o ID de cliente da sua conta. O ID de cliente começa com C.

Você vai precisar do ID de cliente em uma etapa posterior.
Feche o Admin Console.

Implantar o aplicativo

Agora está tudo pronto para implantar o aplicativo de acesso just-in-time no App Engine ou no Cloud Run.

App Engine

Para implantar o aplicativo Just-In-Time Access no App Engine, siga as etapas a seguir.

No Cloud Shell, defina uma variável de ambiente para conter o ID de cliente da sua conta do Cloud Identity ou do Google Workspace:
```
ACCOUNT_CUSTOMER_ID=CUSTOMER_ID
```
Substitua CUSTOMER_ID pelo ID de cliente que você procurou.
Crie um aplicativo do App Engine:
```
gcloud app create --region LOCATION
```
Substitua LOCATION por um local do App Engine compatível.

Conceda à conta de serviço padrão do App Engine os papéis de Gravação de criação no push do Artifact Registry (roles/artifactregistry.createOnPushWriter) e Administrador de armazenamento (roles/storage.admin) para permitir que o App Engine use o Artifact Registry.

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

Clone o repositório do GitHub e mude para a ramificação latest:

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

Crie um arquivo de configuração para o aplicativo 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

Nesse arquivo de configuração, é possível personalizar os valores das variáveis. Para ver uma lista de configurações, consulte a página Opções de configuração no repositório do GitHub associado.

Implante o aplicativo:
```
gcloud app deploy --appyaml app.yaml
```
Anote o target url na saída. Esse será o URL público do aplicativo de acesso just-in-time.

Se a mensagem de erro NOT_FOUND: Unable to retrieve P4SA for exibida, tente executar novamente o comando.

Cloud Run

Para implantar o aplicativo Just-In-Time Access no Cloud Run, siga as etapas a seguir.

No Cloud Shell, defina uma variável de ambiente para conter o ID de cliente da sua conta do Cloud Identity ou do Google Workspace:
```
ACCOUNT_CUSTOMER_ID=CUSTOMER_ID
```
Substitua CUSTOMER_ID pelo ID de cliente que você procurou.
Selecione uma região para implantar:
```
gcloud config set run/region REGION
```
Substitua REGION por uma região compatível com o Cloud Run.
Crie um serviço de back-end:
```
gcloud compute backend-services create jitaccess-backend \
  --load-balancing-scheme=EXTERNAL \
  --global
```
Posteriormente, você usará esse serviço de back-end para configurar um balanceador de carga e o IAP.

Clone o repositório do GitHub e mude para a ramificação latest:

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

Crie o aplicativo e envie a imagem do contêiner para o 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

Crie um arquivo de configuração para o aplicativo 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

Implante o aplicativo:
```
gcloud run services replace app.yaml
```

Configurar um balanceador de carga

Agora você vai configurar um balanceador de carga para o aplicativo de acesso just-in-time.

App Engine

O App Engine configura o balanceador de carga automaticamente.

Cloud Run

Configure um balanceador de carga HTTPS para o serviço do Cloud Run:

Reserve um endereço IP externo estático para o balanceador de carga.
```
gcloud compute addresses create jitaccess-ip --global
```
Crie um certificado SSL gerenciado para o balanceador de carga:
```
gcloud compute ssl-certificates create jitaccess \
  --domains PUBLIC_FQDN \
  --global
```
em que PUBLIC_FQDN é o nome de domínio totalmente qualificado (FQDN) público que você quer usar, por exemplo, jitaccess.example.com.

Procure o endereço IP do balanceador de carga:

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

Crie um registro DNS A na zona de DNS pública que aponte para o endereço IP do balanceador de carga. O nome totalmente qualificado do registro DNS precisa corresponder ao nome usado no certificado SSL.

Observação: pode levar vários minutos ou horas para que o novo registro DNS seja propagado. Durante esse período, o certificado SSL gerenciado não pode ser usado. Para detalhes, consulte Solução de problemas de certificados gerenciados pelo Google.

Crie um grupo de endpoints de rede sem servidor para o serviço do Cloud Run e o conecte ao serviço de back-end:

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)

Crie um front-end de balanceador de carga que use o endereço IP externo e encaminhe o tráfego para o serviço de back-end:

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

Configurar o Identity-Aware Proxy

Agora configure o IAP para o aplicativo Just-In-Time Access.

No Cloud Shell, configure uma tela de consentimento do OAuth:

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

No console do Google Cloud, acesse Segurança > Identity-Aware Proxy.

Acessar o IAP
Defina IAP como habilitado.

Agora defina quais usuários têm permissão para acessar o aplicativo de Just-In-Time Access. É possível conceder acesso a usuários individuais, a grupos ou a todo um domínio.

No console do Google Cloud, acesse IAM e administrador > IAM.

Acessar IAM
Clique em Conceder acesso e defina os seguintes valores:
1. Na lista de participantes, selecione um usuário, um grupo ou um domínio.
2. Na lista de papéis, selecione Usuário do app da Web protegido pelo IAP.
O papel de usuário do app da Web protegido pelo IAP permite que os usuários abram o aplicativo Just-In-Time Access, mas o papel ainda não fornece acesso a nenhum outro recurso.
Clique em Salvar.

A vinculação de papéis pode levar alguns minutos para entrar em vigor.

App Engine

A configuração do IAP está concluída.

Cloud Run

Para concluir a configuração do IAP, conceda o papel Invocador do Cloud Run (roles/run.invoker) ao agente de serviço usado pelo 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"

Testar o acesso just-in-time

Agora você pode testar o processo de concessão de acesso qualificado e o processo de uso do aplicativo de acesso just-in-time para ativar o acesso qualificado.

Permitir acesso qualificado

Para começar, conceda acesso qualificado a um segundo usuário do Cloud Identity ou do Google Workspace.

No Console do Google Cloud, use a lista de projetos para selecionar um projeto que faz parte da hierarquia de recursos gerenciada pelo aplicativo Just-In-Time Access.
Na página do IAM, clique em Conceder acesso.
Digite o endereço de e-mail do segundo usuário do Cloud Identity ou do Google Workspace e selecione um papel como Projeto > Navegador.
Clique em Adicionar condição.
Digite um título como Eligible for JIT access.
Selecione Editor de condições e insira a seguinte expressão CEL:
```
has({}.jitAccessConstraint)
```
Salve as alterações.

Ativar acesso

Agora você pode mudar os usuários e solicitar acesso temporário a um recurso.

Abra uma janela anônima do navegador e acesse o URL do aplicativo Just-In-Time Access que você anotou anteriormente.
Faça login como o usuário para quem você concedeu acesso qualificado.
No aplicativo Just-In-Time Access, selecione o papel e o recurso para o qual você quer ativar o acesso.
Digite uma justificativa, como testing, e clique em Solicitar acesso.

Na próxima página, observe que o acesso foi ativado temporariamente.

Analisar registros

Agora você pode voltar para o usuário administrativo e analisar o registro.

No console do Google Cloud, acesse Geração de registros > Explorador de registros.

Acessar o Explorador de registros
Defina Mostrar consulta como habilitado.
Digite a seguinte consulta:
```
labels.event="api.activateRole"
```

Clique em Run query.

O resultado será assim:

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

Observe que um registro foi criado para cada papel ativado. O registro inclui um conjunto de rótulos que podem ser usados para criar filtros personalizados.

Fazer upgrade do acesso just-in-time

Nesta seção, descrevemos como fazer upgrade de uma implantação de acesso just-in-time para usar uma versão mais recente do aplicativo ou uma configuração diferente.

Esta seção pressupõe que você é um administrador.

No console do Google Cloud, mude para seu projeto e abra o Cloud Shell.

Abra o Cloud Shell
Defina uma variável de ambiente que contenha o ID do projeto:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo ID do seu projeto.

Clone o repositório do GitHub e mude para a ramificação latest:

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

Faça o download do arquivo de configuração usado anteriormente para implantar o aplicativo e salvá-lo em um arquivo 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 o download do arquivo app.yaml falhar, será possível fazer o download da configuração atual no Console do Google Cloud.

Cloud Run

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

Substitua REGION pela região que contém a implantação atual do Cloud Run.

Para fazer mudanças na configuração, edite o arquivo app.yaml. Para ver uma lista de configurações, consulte a página Opções de configuração no repositório do GitHub associado.

Implante o aplicativo:

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

A seguir

Configure a aprovação de várias partes.
Saiba como usar o acesso baseado no contexto para proteger o acesso ao Just-In-Time Access.
Leia mais sobre as condições do IAM.
Configure um domínio personalizado para o aplicativo Just-In-Time Access.
Para mais arquiteturas de referência, diagramas e práticas recomendadas, confira a Central de arquitetura do Cloud.