Usar um registro de imagem particular

Por padrão, sua instalação do GKE na AWS pode acessar imagens de contêiner públicas. Neste tópico, explicamos como usar o GKE na AWS com um repositório de imagens de contêiner particular, como o Artifact Registry.

A partir da versão 1.28, o GKE na AWS oferece uma maneira de extrair imagens particulares do Artifact Registry ou do Container Registry sem precisar usar um secret do Kubernetes. Para mais detalhes, consulte Usar um registro de imagens particulares sem secrets.

Antes de começar

Para executar as etapas desta página, primeiro conclua o seguinte:

• Crie um cluster.
• Crie um pool de nós.

• Configure o acesso do cluster para o kubectl.

• Crie uma imagem do Docker e a envie para o Artifact Registry. Os exemplos nesta página usam o contêiner hello-app. Para criar esse contêiner, siga as etapas em Criar uma imagem de contêiner e Enviar a imagem do Docker ao Artifact Registry, parte da documentação do GKE no Google Cloud.

Verificar se há imagens no Artifact Registry

Para concluir o restante destas etapas, você precisa de uma imagem de contêiner. Veja o nome das suas imagens de contêiner executando as seguintes etapas:

1. Configure a ferramenta de linha de comando do Docker para autenticar no Artifact Registry com o SDK do Google Cloud:

   gcloud auth configure-docker
   

   A ferramenta de linha de comando gcloud registra um auxiliar de credencial para todos os registros do Docker compatíveis com o Google.

2. Confirme se o Artifact Registry inclui uma imagem com o comando docker images.

   docker images
   

   O Docker se conecta ao Artifact Registry e retorna as imagens disponíveis no seu repositório. Por exemplo, a resposta abaixo mostra uma imagem de contêiner chamada hello-app no repositório PROJECT_NAME em us-west1-docker.pkg.dev.

   REPOSITORY                                                            TAG          IMAGE ID       CREATED          SIZE
   us-west1-docker.pkg.dev/PROJECT_NAME/hello-repo/hello-app   v1           f7cfe0d58569   21 minutes ago   11.5MB
   

Se você não tiver uma imagem de contêiner pronta, crie uma seguindo as etapas em Como implantar um aplicativo em contêiner.

Crie uma conta de serviço

Observação: a seguinte conta de serviço terá acesso a todas as imagens em seu projeto. Para mais informações sobre como restringir o acesso, consulte Como conceder permissões na documentação do Artifact Registry.

Os clusters são autenticados usando uma conta de serviço do Identity and Access Management (IAM).

Para criar uma nova conta de serviço, siga estas etapas:

1. Crie uma conta de serviço do IAM com a Google Cloud CLI.

   gcloud iam service-accounts create ACCOUNT_NAME
   

   Substitua ACCOUNT_NAME pelo nome da nova conta de serviço do Google Cloud.

2. Conceda as permissões do Artifact Registry à conta de serviço.

   gcloud projects add-iam-policy-binding PROJECT_NAME \
     --member serviceAccount:ACCOUNT_NAME@PROJECT_NAME.iam.gserviceaccount.com \
     --role roles/artifactregistry.reader
   

   Substitua:

   • PROJECT_NAME pelo projeto do Google Cloud
   • ACCOUNT_NAME pelo nome da conta de serviço do Google Cloud

3. Faça o download da chave da conta de serviço.

   gcloud iam service-accounts keys create registry-access-key.json \
     --iam-account ACCOUNT_NAME@PROJECT_NAME.iam.gserviceaccount.com
   

   Substitua:

   • PROJECT_NAME
   • ACCOUNT_NAME
   Observação: a chave da conta de serviço permite acesso a recursos privilegiados. Proteja o arquivo de chave após o download.

Agora está tudo pronto para configurar o cluster de usuário para se conectar ao Artifact Registry.

Salve a chave no cluster

Para fornecer a chave para autenticação no Artifact Registry, salve a chave da conta de serviço como um secret do Kubernetes com estas etapas:

1. Use kubectl para criar o Secret.

     kubectl create secret docker-registry registry-secret \
     --docker-server=LOCATION-docker.pkg.dev \
     --docker-username=_json_key \
     --docker-email=ACCOUNT_NAME@PROJECT_NAME.iam.gserviceaccount.com \
     --docker-password="$(cat registry-access-key.json)"
   

   Substitua:

   • LOCATION é o local regional ou multirregional do repositório.
   • PROJECT_NAME
   • ACCOUNT_NAME

2. Exclua a cópia local da chave da conta de serviço.

   rm registry-access-key.json
   

Agora você pode referir-se a esse secret nas suas cargas de trabalho.

Criar uma carga de trabalho com uma imagem particular

Para usar uma imagem de um repositório de contêiner particular com uma carga de trabalho, defina o campo spec.imagePullSecrets como seu nome do secret. Esse campo está em locais diferentes para pods e implantações.

Como criar um pod

Para criar um pod, que pode acessar o registro de contêiner, defina o campo spec.imagePullSecrets como o nome do secret.

1. Crie um pod que especifique spec.imagePullSecrets.

   apiVersion: v1
   kind: Pod
   metadata:
     name: POD_NAME
   spec:
     containers:
     - name: CONTAINER_NAME
       image: LOCATION-docker.pkg.dev/PROJECT_NAME/hello-repo/hello-app:v1
     imagePullSecrets:
     - name: registry-secret
   

   Substitua:

   • POD_NAME: o nome do pod
   • CONTAINER_NAME: o nome do contêiner dentro do pod
   • LOCATION
   • PROJECT_NAME

   Por exemplo, para extrair a imagem hello-app, copie o YAML a seguir em um arquivo chamado hello-pod.yaml.

   apiVersion: v1
   kind: Pod
   metadata:
     name: hello-pod
   spec:
     containers:
     - name: hello-container
       image: us-west1-docker.pkg.dev/example-project/hello-repo/hello-app:v1
     imagePullSecrets:
     - name: registry-secret
   

2. Aplique a configuração ao cluster com kubectl.

   kubectl apply -f hello-pod.yaml
   

3. Confirme se o pod está sendo executado com kubectl get.

   kubectl get pod/hello-pod
   

   A resposta inclui um pod com status Running.

   NAME        READY   STATUS    RESTARTS   AGE
   hello-pod   1/1     Running   0          15s
   

Como criar uma implantação

1. Para usar um repositório particular em uma implantação, especifique o imagePullSecret dentro do modelo.

   Por exemplo, para configurar uma implantação que use a imagem hello-app, crie um arquivo chamado hello-deployment.yaml com o seguinte conteúdo:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: hello-app-deployment
   spec:
     selector:
       matchLabels:
         app: products
         department: sales
     replicas: 3
     template:
       metadata:
         labels:
           app: products
           department: sales
       spec:
         containers:
         - name: hello
           image: LOCATION-docker.pkg.dev/PROJECT_NAME/hello-repo/hello-app:v1
           env:
           - name: "PORT"
             value: "50001"
         imagePullSecrets:
         - name: registry-secret
   

   Observação: imagePullSecrets precisa ter o mesmo nível de recuo que containers.

   Substitua:

   • LOCATION
   • PROJECT_NAME

2. Aplique a configuração ao cluster com kubectl.

   kubectl apply -f hello-deployment.yaml
   

3. Confirme se a implantação está em execução com kubectl pods.

   kubectl get pods --selector=app=products
   

   A saída exibe três pods Running.

   NAME                                    READY   STATUS    RESTARTS   AGE
   hello-app-deployment-67d9c6d98c-b69f2   1/1     Running   0          14m
   hello-app-deployment-67d9c6d98c-d6k5c   1/1     Running   0          14m
   hello-app-deployment-67d9c6d98c-p2md5   1/1     Running   0          14m
   

Limpar

Para remover os recursos criados nesta página, execute estes comandos:

kubectl apply -f hello-pod.yaml
kubectl delete -f hello-deployment.yaml

A seguir

• Leia a visão geral do Artifact Registry.