Como testar um serviço do Cloud Run localmente

Durante o desenvolvimento, é possível executar e testar a imagem de contêiner localmente, antes da implantação. É possível usar o Cloud Code ou o Docker instalado localmente para executar e testar no local com acesso aos serviços do Google Cloud.

Emulador do Cloud Code

O plug-in do Cloud Code para os ambientes de desenvolvimento integrado do VS Code e da JetBrains permite executar e depurar localmente sua imagem de contêiner em um emulador do Cloud Run no seu ambiente de desenvolvimento integrado. O emulador permite configurar um ambiente que representa o serviço em execução no Cloud Run.

É possível configurar propriedades como alocação de memória e CPU, especificar variáveis de ambiente e definir conexões de banco de dados do Cloud SQL.

Instale o Cloud Code em um ambiente de desenvolvimento integrado do VS Code ou da JetBrains (links em inglês).
Siga as instruções para desenvolver e depurar localmente no ambiente de desenvolvimento integrado.
VS Code: desenvolvimento e depuração no local
IntelliJ: desenvolvimento e depuração no local

CLI gcloud

A Google Cloud CLI contém um ambiente de desenvolvimento local para emular o Cloud Run. Ele pode criar um contêiner a partir da origem, executar o contêiner na máquina local e recriar o contêiner automaticamente quando o código-fonte é alterado.

Para iniciar o ambiente de desenvolvimento local, siga estas etapas:

Altere o diretório para o diretório que contém o código-fonte do seu serviço.
Invocar o comando:
```
gcloud beta code dev
```

Se houver um Dockerfile no diretório local, ele será usado para criar o contêiner. Se não houver um Dockerfile, o contêiner será criado com os buildpacks do Google Cloud.

Para ver o serviço em execução, acesse http://localhost:8080/ no seu navegador. Caso tenha especificado uma porta personalizada com a opção --local-port, lembre-se de abrir seu navegador para ela.

Para interromper o servidor local:

Mac OS e Linux: Control-C
Windows: Control-Break

Como personalizar a configuração do serviço

É possível personalizar a configuração do Cloud Run do serviço em execução localmente usando um arquivo YAML. O formato YAML é o mesmo que pode ser usado para implantar um serviço do Cloud Run, mas é suportado apenas por um subconjunto das configurações do serviço do Cloud Run. O gcloud beta code dev procura e usa qualquer arquivo que termine em *.service.dev.yaml no diretório atual. Se nenhum for encontrado, ele usará qualquer arquivo que termine com *.service.yaml.

É possível definir as seguintes configurações para desenvolvimento local:

O campo de contêiner image não é obrigatório para o desenvolvimento local, porque a imagem é criada e fornecida ao serviço quando o comando é executado.

Use o exemplo de arquivo service.dev.yaml a seguir para desenvolvimento local:

  apiVersion: serving.knative.dev/v1
  kind: Service
  metadata:
    name: my-service-name
  spec:
    template:
      spec:
        containers:
        - env:
          - name: FOO
            value: bar

Como usar credenciais

Para conceder permissão ao contêiner para usar os serviços do Google Cloud, você precisa fornecer a ele uma credencial de acesso.

Para conceder ao contêiner acesso a uma credencial usando sua própria conta, faça login usando gcloud e use a sinalização --application-default-credential:
```
gcloud auth application-default login
gcloud beta code dev --dockerfile=PATH_TO_DOCKERFILE --application-default-credential
```
Para fornecer as credenciais do aplicativo como uma conta de serviço, use a sinalização --service-account:
```
gcloud beta code dev --dockerfile=PATH_TO_DOCKERFILE --service-account=SERVICE_ACCOUNT_EMAIL
```
A sinalização --service-account faz o download e o armazenamento em cache de uma chave de conta de serviço localmente. O usuário é responsável por manter a chave segura e excluí-la quando não for mais necessária.

Docker

Para testar sua imagem de contêiner localmente usando o Docker, siga estas etapas:

Use o comando do Docker:
```
PORT=8080 && docker run -p 9090:${PORT} -e PORT=${PORT} IMAGE_URL
```
Substitua IMAGE_URL por uma referência à imagem de contêiner. Por exemplo, us-docker.pkg.dev/cloudrun/container/hello:latest.

A variável de ambiente PORT especifica a porta que o aplicativo usará para detectar solicitações HTTP ou HTTPS. Esse é um requisito do contrato do ambiente de execução do contêiner. Neste exemplo, usamos a porta 8080.

Importante: ao executar localmente pela primeira vez:
Se esta for a primeira vez que você está tentando executar localmente, talvez não tenha todas as permissões necessárias para acessar a imagem do registro de imagens que está usando. Se você usar o Artifact Registry, siga as instruções de autenticação do Artifact Registry. Se você usa o Container Registry, siga as instruções de autenticação do Container Registry. Depois de configurar o registro corretamente, tente executar o contêiner do Cloud Run localmente novamente.
Atenção: usando a conta de serviço padrão:
Se você depender da conta de serviço padrão ao implantar no Cloud Run, esteja ciente de que ela não está disponível localmente. Portanto, é necessário ter uma conta de serviço junto com um par de chaves públicas/privadas salvo localmente para executar essa imagem localmente com o Docker. Para mais informações, consulte a próxima guia Acesso ao Docker com o Google Cloud.
Abra http://localhost:9090 no seu navegador.

Se você tem pouca experiência trabalhando com contêineres, consulte o guia de primeiros passos com o Docker. Para saber mais sobre os comandos do Docker, consulte a documentação do Docker.

Acesso ao Docker com o Google Cloud

Se você estiver usando bibliotecas de cliente do Google Cloud para integrar seu aplicativo aos serviços do Google Cloud e ainda não tiver protegido esses serviços para controlar o acesso externo, será possível configurar o contêiner local para autenticação com o Google Cloud. serviços com o Application Default Credentials.

Para executar localmente:

Consulte Primeiros passos da autenticação para ver instruções sobre como gerar, recuperar e configurar as credenciais da conta de serviço.
As sinalizações de execução do Docker a seguir injetam as credenciais e a configuração do seu sistema local no contêiner local:
1. Use a sinalização --volume (-v) para injetar o arquivo de credencial no contêiner (presumindo que você já tenha definido a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS na máquina):
```
-v $GOOGLE_APPLICATION_CREDENTIALS:/tmp/keys/FILE_NAME.json:ro
```
2. Use a sinalização --environment (-e) para definir a variável GOOGLE_APPLICATION_CREDENTIALS no contêiner:
```
-e GOOGLE_APPLICATION_CREDENTIALS=/tmp/keys/FILE_NAME.json
```
Como opção, use este comando run do Docker totalmente configurado:
```
PORT=8080 && docker run \
-p 9090:${PORT} \
-e PORT=${PORT} \
-e K_SERVICE=dev \
-e K_CONFIGURATION=dev \
-e K_REVISION=dev-00001 \
-e GOOGLE_APPLICATION_CREDENTIALS=/tmp/keys/FILE_NAME.json \
-v $GOOGLE_APPLICATION_CREDENTIALS:/tmp/keys/FILE_NAME.json:ro \
IMAGE_URL
```
Observe que o caminho
```
/tmp/keys/FILE_NAME.json
```
mostrado no exemplo acima é um local razoável para colocar suas credenciais no contêiner.

No entanto, outros locais de diretório também funcionarão. O requisito crucial é que a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS precisa corresponder ao local de ativação da vinculação dentro do contêiner.

Além disso, com alguns serviços do Google Cloud, convém usar uma configuração alternativa para isolar a solução de problemas local do desempenho de produção e dos dados.

A seguir

Para saber como solucionar problemas de um aplicativo do Cloud Run com falha localmente, consulte o tutorial Solução de problemas locais de um serviço do Cloud Run.
Para saber como implantar seus contêineres criados, veja Como implantar serviços.