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:

    Captura de tela do aplicativo Just-In-Time Access que mostra dois papéis qualificados e um ativado.

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

    Captura de tela do app Just-In-Time Access que mostra o formulário para inserir uma justificativa.

    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.

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

    Go to project selector

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

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

  2. Abra o Cloud Shell.

    Abrir o Cloud Shell

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

  4. 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)")
    
  5. 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:

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

  1. Abra o Google Admin Console e faça login como usuário superadministrador.

  2. Acesse Conta > Papéis do administrador:

    Acesse Funções do administrador

  3. Clique em Leitor de grupos > Administradores.

  4. Clique em Atribuir contas de serviço.

  5. Digite o seguinte endereço de e-mail:

    jitaccess@PROJECT_ID.iam.gserviceaccount.com
    

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

  6. Clique em Adicionar.

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

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

    Acessar as configurações da conta

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

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

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

  2. Crie um aplicativo do App Engine:

    gcloud app create --region LOCATION
    

    Substitua LOCATION por um local do App Engine compatível.

  3. 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
    
  4. 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
    
  5. 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.

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

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

  2. Selecione uma região para implantar:

    gcloud config set run/region REGION
    

    Substitua REGION por uma região compatível com o Cloud Run.

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

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

    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.

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

  1. Reserve um endereço IP externo estático para o balanceador de carga.

    gcloud compute addresses create jitaccess-ip --global
    
  2. 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.

  3. Procure o endereço IP do balanceador de carga:

    gcloud compute addresses describe jitaccess-ip \
      --global \
      --format=value\(address\)
    
  4. 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.

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

  1. 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)
    
  2. No console do Google Cloud, acesse Segurança > Identity-Aware Proxy.

    Acessar o IAP

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

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

    Acessar IAM

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

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

  1. 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.
  2. Na página do IAM, clique em Conceder acesso.
  3. 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.
  4. Clique em Adicionar condição.
  5. Digite um título como Eligible for JIT access.
  6. Selecione Editor de condições e insira a seguinte expressão CEL:

    has({}.jitAccessConstraint)
    
  7. Salve as alterações.

Ativar acesso

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

  1. Abra uma janela anônima do navegador e acesse o URL do aplicativo Just-In-Time Access que você anotou anteriormente.
  2. Faça login como o usuário para quem você concedeu acesso qualificado.
  3. No aplicativo Just-In-Time Access, selecione o papel e o recurso para o qual você quer ativar o acesso.
  4. 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.

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

    Acessar o Explorador de registros

  2. Defina Mostrar consulta como habilitado.

  3. Digite a seguinte consulta:

    labels.event="api.activateRole"
    
  4. 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.

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

    Abra o Cloud Shell

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

  3. 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
    
  4. 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.

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

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