Use um registro de imagem privado

Sua instalação do GKE na AWS pode acessar imagens de contêiner públicas por padrão. Este tópico explica como usar o GKE na AWS com um repositório privado de imagens de contêiner, como o Artifact Registry .

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

Antes de começar

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

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

• Configurar acesso ao cluster para kubectl .

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

Verifique as imagens no Registro de Artefatos

Para concluir o restante dessas etapas, você precisa de uma imagem de contêiner. Obtenha 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 Google Cloud SDK:

   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 seu 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 Implantando um aplicativo em contêiner .

Criar uma conta de serviço

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

Seus clusters são autenticados usando uma conta de serviço de Gerenciamento de Identidade e Acesso (IAM).

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

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

   gcloud iam service-accounts create ACCOUNT_NAME
   

   Substitua ACCOUNT_NAME pelo nome do novo Google Cloudconta de serviço.

2. Conceda 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 o seguinte:

   • PROJECT_NAME com seu Google Cloud projeto
   • ACCOUNT_NAME com seu Google Cloud nome da conta de serviço

3. Baixe a chave da conta de serviço da conta.

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

   Substitua o seguinte:

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

Agora você está pronto para configurar seu cluster de usuários para se conectar ao Artifact Registry.

Salve a chave do seu cluster

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

1. Use kubectl para criar o segredo.

     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 o seguinte:

   • LOCATION : a localização regional ou multirregional do repositório.
   • PROJECT_NAME
   • ACCOUNT_NAME

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

   rm registry-access-key.json
   

Agora você pode referenciar este segredo em suas cargas de trabalho.

Crie uma carga de trabalho com uma imagem privada

Para usar uma imagem de um repositório de contêineres privado com uma carga de trabalho, defina o campo spec.imagePullSecrets como o nome do seu segredo. Este campo está em locais diferentes para Pods e Implantações .

Criando um Pod

Para criar um Pod que possa acessar o registro do contêiner, defina o campo spec.imagePullSecrets como seu nome Secreto.

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 o seguinte:

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

   Por exemplo, para extrair a imagem hello-app , copie o seguinte YAML 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 seu cluster com kubectl .

   kubectl apply -f hello-pod.yaml
   

3. Confirme se o pod está em execução 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
   

Criando uma implantação

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

   Por exemplo, para configurar uma implantação que usa 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 deve ter o mesmo nível de recuo que containers .

   Substitua o seguinte:

   • LOCATION
   • PROJECT_NAME

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

   kubectl apply -f hello-deployment.yaml
   

3. Confirme se sua implantação está sendo executada 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 que você criou nesta página, execute estes comandos:

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

O que vem a seguir

• Leia a visão geral do Registro de Artefatos .