Pré-requisitos Etapa 1: configurar sua máquina de desenvolvimento Etapa 2: criar um cluster Amazon EKS Etapa 3: Criar um repositório de imagens do Amazon ECR Etapa 4: Adicionar arquivos de origem Etapa 5: criar AWS funções Etapa 6: Adicionar AWS funções a CodeCatalyst Etapa 7: atualizar o ConfigMap Etapa 8: criar e executar um fluxo de trabalho Etapa 9: faça uma alteração nos arquivos de origem Limpeza

Tutorial: Implantar um aplicativo no Amazon EKS

Neste tutorial, você aprende a implantar um aplicativo em contêineres no Amazon Elastic Kubernetes Service usando CodeCatalyst um fluxo de trabalho da Amazon, o Amazon EKS e alguns outros serviços. AWS O aplicativo implantado é um simples “Hello, World!” site construído em uma imagem Docker do servidor web Apache. O tutorial mostra o trabalho de preparação necessário, como configurar uma máquina de desenvolvimento e um cluster Amazon EKS, e depois descreve como criar um fluxo de trabalho para criar o aplicativo e implantá-lo no cluster.

Após a conclusão da implantação inicial, o tutorial instrui você a fazer uma alteração na fonte do aplicativo. Essa alteração faz com que uma nova imagem do Docker seja criada e enviada ao seu repositório de imagens do Docker com as novas informações de revisão. A nova revisão da imagem do Docker é então implantada no Amazon EKS.

dica

Em vez de seguir este tutorial, você pode usar um blueprint que faz uma configuração completa do Amazon EKS para você. Você precisará usar o plano EKS App Deployment. Para ter mais informações, consulte Criando um projeto com um blueprint.

Tópicos

Pré-requisitos
Etapa 1: configurar sua máquina de desenvolvimento
Etapa 2: criar um cluster Amazon EKS
Etapa 3: Criar um repositório de imagens do Amazon ECR
Etapa 4: Adicionar arquivos de origem
Etapa 5: criar AWS funções
Etapa 6: Adicionar AWS funções a CodeCatalyst
Etapa 7: atualizar o ConfigMap
Etapa 8: criar e executar um fluxo de trabalho
Etapa 9: faça uma alteração nos arquivos de origem
Limpeza

Pré-requisitos

Antes de começar este tutorial:

Você precisa de um CodeCatalyst espaço na Amazon com uma AWS conta conectada. Para ter mais informações, consulte Criando um espaço.
Em seu espaço, você precisa de um CodeCatalyst projeto vazio, Start from scratch, chamado:
```
codecatalyst-eks-project
```
Para ter mais informações, consulte Criando um projeto vazio na Amazon CodeCatalyst.
Em seu projeto, você precisa de um repositório de CodeCatalyst código-fonte vazio chamado:
```
codecatalyst-eks-source-repository
```
Para ter mais informações, consulte Armazene e colabore no código com repositórios de origem no CodeCatalyst.
Em seu projeto, você precisa de um ambiente de CodeCatalyst CI/CD (não um ambiente de desenvolvimento) chamado:
```
codecatalyst-eks-environment
```
Configure esse ambiente da seguinte forma:
- Escolha qualquer tipo, como Não produção.
- Conecte sua AWS conta a ela.
- Para a função padrão do IAM, escolha qualquer função. Você especificará uma função diferente posteriormente.
Para ter mais informações, consulte Implantação em Contas da AWS e VPCs com ambientes CodeCatalyst.

Etapa 1: configurar sua máquina de desenvolvimento

A primeira etapa deste tutorial é configurar uma máquina de desenvolvimento com algumas ferramentas que você usará ao longo deste tutorial. Essas ferramentas são:

o eksctl utilitário — para criação de clusters
a kubectl utilidade — um pré-requisito para eksctl
o AWS CLI — também um pré-requisito para eksctl

Você pode instalar essas ferramentas em sua máquina de desenvolvimento existente, se tiver uma, ou pode usar um ambiente de CodeCatalyst desenvolvimento baseado em nuvem. A vantagem de um ambiente de CodeCatalyst desenvolvimento é que ele é fácil de ativar e desativar e está integrado a outros CodeCatalyst serviços, permitindo que você conclua este tutorial em menos etapas.

Este tutorial pressupõe que você usará um ambiente de CodeCatalyst desenvolvimento.

As instruções a seguir descrevem uma maneira rápida de iniciar um ambiente de CodeCatalyst desenvolvimento e configurá-lo com as ferramentas necessárias, mas se você quiser instruções detalhadas, consulte:

Criar um ambiente de desenvolvimento neste guia.
Instalação do kubectl no Guia do usuário do Amazon EKS.
Instalação ou atualização do eksctl no Guia do usuário do Amazon EKS.
Instalando ou atualizando a versão mais recente do AWS CLI no Guia AWS Command Line Interface do Usuário.

Para iniciar um ambiente de desenvolvimento

Abra o CodeCatalyst console em https://codecatalyst.aws/.
Navegue até seu projeto,codecatalyst-eks-project.
No painel de navegação, selecione Código e, em seguida, selecione Repositórios de origem.
Escolha o nome do seu repositório de origem,codecatalyst-eks-source-repository.
Na parte superior, escolha Create Dev Environment e, em seguida, escolha AWS Cloud9 (no navegador).
Certifique-se de que Trabalhar na ramificação e principal existentes estejam selecionadas e, em seguida, escolha Criar.

Seu ambiente de desenvolvimento é iniciado em uma nova guia do navegador e seu repositório (codecatalyst-eks-source-repository) é clonado nela.

Para instalar e configurar o kubectl

No terminal do Dev Environment, digite:


curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl

Digite:
```
chmod +x ./kubectl
```

Digite:


mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin

Digite:


echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc

Digite:
```
kubectl version --short --client
```
Verifique se uma versão aparece.

Agora você instaloukubectl.

Para instalar e configurar o eksctl

nota

eksctlnão é estritamente necessário porque você pode usar kubectl em vez disso. No entanto, eksctl tem a vantagem de automatizar grande parte da configuração do cluster e, portanto, é a ferramenta recomendada para este tutorial.

No terminal do Dev Environment, digite:


curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp

Digite:
```
sudo cp /tmp/eksctl /usr/bin
```
Digite:
```
eksctl version
```
Verifique se uma versão aparece.

Agora você instaloueksctl.

Para verificar se o AWS CLI está instalado

No terminal do Dev Environment, digite:
```
aws --version
```
Verifique se uma versão aparece para verificar se o AWS CLI está instalado.

Conclua os procedimentos restantes para configurar o AWS CLI com as permissões necessárias para acessar AWS.

Para configurar o AWS CLI

Você deve configurar o AWS CLI com chaves de acesso e um token de sessão para dar acesso aos AWS serviços. As instruções a seguir fornecem uma maneira rápida de configurar as chaves e o token, mas se você quiser instruções detalhadas, consulte Configurando o AWS CLI no Guia do AWS Command Line Interface Usuário.

Crie um usuário do IAM Identity Center, da seguinte forma:
1. Faça login no AWS Management Console e abra o AWS IAM Identity Center console em https://console.aws.amazon.com/singlesignon/.
  
  (Talvez seja necessário escolher Ativar se nunca tiver feito login no IAM Identity Center antes.)
  
  nota
  Certifique-se de fazer login usando o Conta da AWS que está conectado ao seu CodeCatalyst espaço. Você pode verificar qual conta está conectada navegando até seu espaço e escolhendo a guia Contas da AWS. Para ter mais informações, consulte Criando um espaço.
2. No painel de navegação, escolha Usuários e depois Adicionar usuário.
3. Em Nome de usuário, digite:
```
codecatalyst-eks-user
```
4. Em Senha, escolha Gerar uma senha de uso único que você possa compartilhar com esse usuário.
5. Em Endereço de e-mail e Confirmar endereço de e-mail, insira um endereço de e-mail que ainda não exista no IAM Identity Center.
6. Em Primeiro nome, insira:
```
codecatalyst-eks-user
```
7. Em Sobrenome, digite:
```
codecatalyst-eks-user
```
8. Em Nome de exibição, mantenha:
```
codecatalyst-eks-user codecatalyst-eks-user
```
9. Escolha Próximo.
10. Na página Adicionar usuário aos grupos, escolha Avançar.
11. Na página Revisar e adicionar usuário, revise as informações e escolha Adicionar usuário.
  
  Uma caixa de diálogo de senha de uso único é exibida.
12. Escolha Copiar e cole as informações de login em um arquivo de texto. As informações de login consistem na URL do portal de AWS acesso, um nome de usuário e uma senha de uso único.
13. Escolha Fechar.
Crie um conjunto de permissões, da seguinte forma:
1. No painel de navegação, escolha Conjuntos de permissões e, em seguida, escolha Criar conjunto de permissões.
2. Escolha Conjunto de permissões predefinido e, em seguida, selecione AdministratorAccess. Essa política fornece permissões completas para todos Serviços da AWS.
3. Escolha Próximo.
4. Em Nome do conjunto de permissões, remova AdministratorAccess e digite:
```
codecatalyst-eks-permission-set
```
5. Escolha Próximo.
6. Na página Revisar e criar, revise as informações e selecione Criar.
Atribua o conjunto de permissões paracodecatalyst-eks-user, da seguinte forma:
1. No painel de navegação Contas da AWS, escolha e marque a caixa de seleção ao lado da caixa de seleção na Conta da AWS qual você está conectado no momento.
2. Escolha Atribuir usuários ou grupos.
3. Escolha a guia Users.
4. Marque a caixa de seleção ao lado dos logs do codecatalyst-eks-user.
5. Escolha Próximo.
6. Marque a caixa de seleção ao lado dos logs do codecatalyst-eks-permission-set.
7. Escolha Próximo.
8. Revise suas informações e selecione Enviar.
  
  Agora você designou codecatalyst-eks-user e codecatalyst-eks-permission-set para o seu Conta da AWS, unindo-os.
Obtenha as chaves codecatalyst-eks-user de acesso e o token de sessão da seguinte forma:
1. Verifique se você tem a URL do portal de AWS acesso, o nome de usuário e a senha de uso único paracodecatalyst-eks-user. Você deveria ter copiado essas informações para um editor de texto anteriormente.
  
  nota
  Se você não tiver essas informações, acesse a página de codecatalyst-eks-user detalhes no IAM Identity Center, escolha Redefinir senha, Gerar uma senha de uso único [...] e redefina a senha novamente para exibir as informações na tela.
2. Sair de AWS.
3. Cole o URL do portal de AWS acesso na barra de endereço do seu navegador.
4. Faça login com:
  - Nome de usuário:
```
codecatalyst-eks-user
```
  - Senha:
    
    one-time-password
5. Em Definir nova senha, insira uma nova senha e escolha Definir nova senha.
  
  Uma caixa de Conta da AWS aparece na tela.
6. Escolha e Conta da AWS, em seguida, escolha o nome do Conta da AWS ao qual você atribuiu o codecatalyst-eks-user usuário e o conjunto de permissões.
7. Ao lado decodecatalyst-eks-permission-set, escolha Linha de comando ou acesso programático.
8. Copie os comandos no meio da página. Eles são parecidos com os seguintes:
```
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
export AWS_SESSION_TOKEN="session-token"
```
  ... onde o token de sessão é uma longa sequência aleatória.
Adicione as chaves de acesso e o token de sessão ao AWS CLI, da seguinte forma:
1. Retorne ao seu ambiente de CodeCatalyst desenvolvimento.
2. No prompt do terminal, cole os comandos que você copiou. Pressione Enter.
  
  Agora você configurou o AWS CLI com chaves de acesso e um token de sessão. Agora você pode usar AWS CLI para concluir as tarefas exigidas por este tutorial.
  
  Importante
  Se, em algum momento durante este tutorial, você ver mensagens semelhantes a:
  Unable to locate credentials. You can configure credentials by running "aws configure".
  Ou:
  ExpiredToken: The security token included in the request is expired
  ... é porque sua AWS CLI sessão expirou. Nesse caso, não execute o aws configure comando. Em vez disso, use as instruções na etapa 4 desse procedimento, que começa com, Obtain codecatalyst-eks-user's access key and session token para atualizar sua sessão.

Etapa 2: criar um cluster Amazon EKS

Nesta seção, você cria um cluster no Amazon EKS. As instruções abaixo descrevem uma maneira rápida de criar o cluster usandoeksctl, mas se você quiser instruções detalhadas, consulte:

Introdução ao eksctl no Guia do usuário do Amazon EKS

ou
Introdução ao console e AWS CLI ao Guia do usuário do Amazon EKS (este tópico fornece kubectl instruções para criar o cluster)

nota

Os clusters privados não são compatíveis com a CodeCatalyst integração com o Amazon EKS.

Antes de começar

Certifique-se de ter concluído as seguintes tarefas em sua máquina de desenvolvimento:

Instalou o eksctl utilitário.
Instalou o kubectl utilitário.
Instalei AWS CLI e configurei com chaves de acesso e um token de sessão.

Para obter informações sobre como concluir essas tarefas, consulteEtapa 1: configurar sua máquina de desenvolvimento.

Para criar um cluster

Importante

Não use a interface de usuário do serviço Amazon EKS para criar o cluster porque o cluster não será configurado corretamente. Use o eksctl utilitário, conforme descrito nas etapas a seguir.

Acesse seu ambiente de desenvolvimento.
Crie um cluster e nós:
```
eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
```
Em que:
- codecatalyst-eks-clusteré substituído pelo nome que você deseja dar ao seu cluster.
- us-west-2 é substituído por sua região.
Depois de 10 a 20 minutos, uma mensagem semelhante à seguinte é exibida:

EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready

nota
Você verá várias waiting for CloudFormation stack mensagens ao AWS criar seu cluster. Isso é esperado.

Verifique se seu cluster foi criado com sucesso:


kubectl cluster-info

Você verá uma mensagem semelhante à seguinte, indicando uma criação bem-sucedida do cluster:


Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

Etapa 3: Criar um repositório de imagens do Amazon ECR

Nesta seção, você cria um repositório privado de imagens no Amazon Elastic Container Registry (Amazon ECR). Esse repositório armazena a imagem do Docker para o tutorial.

Para obter mais informações sobre o Amazon ECR, consulte o Guia do usuário do Amazon Elastic Container Registry.

Para criar um repositório de imagens no Amazon ECR

Acesse seu ambiente de desenvolvimento.
Crie um repositório vazio no Amazon ECR:
```
aws ecr create-repository --repository-name codecatalyst-eks-image-repo
```
codecatalyst-eks-image-repoSubstitua pelo nome que você deseja dar ao repositório Amazon ECR.

Este tutorial pressupõe que você nomeou seu repositóriocodecatalyst-eks-image-repo.

Exiba os detalhes do repositório Amazon ECR:


aws ecr describe-repositories \
      --repository-names codecatalyst-eks-image-repo

Observe o “repositoryUri”: valor, por exemplo,111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo.

Você precisará dele mais tarde ao adicionar o repositório ao seu fluxo de trabalho.

Etapa 4: Adicionar arquivos de origem

Nesta seção, você adiciona arquivos de origem do aplicativo ao seu repositório de origem (codecatalyst-eks-source-repository). Eles consistem em:

Um index.html arquivo — Exibe uma mensagem “Hello, World!” mensagem no navegador.
Um Dockerfile — descreve a imagem base a ser usada para sua imagem do Docker e os comandos do Docker a serem aplicados a ela.
Um deployment.yaml arquivo — O manifesto do Kubernetes que define o serviço e a implantação do Kubernetes.

A estrutura de pastas é a seguinte:


|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile

index.html

O index.html arquivo exibe uma mensagem “Hello, World!” mensagem no navegador.

Para adicionar o arquivo index.html

Acesse seu ambiente de desenvolvimento.
Emcodecatalyst-eks-source-repository, crie uma pasta chamadapublic-html.

Em/public-html, crie um arquivo chamado index.html com o seguinte conteúdo:


<html>
  <head>
    <title>Hello World</title>
    <style>
      body {
      background-color: black;
      text-align: center;
      color: white;
      font-family: Arial, Helvetica, sans-serif;
      }  
    </style>
  </head>
  <body>
    <h1>Hello, World!</h1>
  </body>
</html>

No prompt do terminal, digite:


cd /projects/codecatalyst-eks-source-repository

Adicione, confirme e envie:
```
git add .
git commit -m "add public-html/index.html"
git push
```
O index.html é adicionado ao seu repositório em uma public-html pasta.

Dockerfile

O Dockerfile descreve a imagem base do Docker a ser usada e os comandos do Docker a serem aplicados a ela. Para obter mais informações sobre o Dockerfile, consulte a Referência do Dockerfile.

O Dockerfile especificado aqui indica o uso da imagem base do Apache 2.4 (). httpd Também inclui instruções para copiar um arquivo fonte chamado index.html para uma pasta no servidor Apache que serve páginas da web. A EXPOSE instrução no Dockerfile diz ao Docker que o contêiner está escutando na porta 80.

Para adicionar o Dockerfile

Emcodecatalyst-eks-source-repository, crie um arquivo chamado Dockerfile com o seguinte conteúdo:
```
FROM httpd:2.4
COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
EXPOSE 80
```
Não inclua uma extensão de arquivo.

Importante
O Dockerfile deve residir na pasta raiz do seu repositório. O Docker build comando do fluxo de trabalho espera que ele esteja lá.
Adicione, confirme e envie:
```
git add .
git commit -m "add Dockerfile"
git push
```
O Dockerfile é adicionado ao seu repositório.

deployment.yaml

Nesta seção, você adiciona um deployment.yaml arquivo ao seu repositório. O deployment.yaml arquivo é um manifesto do Kubernetes que define dois tipos ou tipos de recursos do Kubernetes a serem executados: um 'serviço' e uma 'implantação'.

O 'serviço' implanta um balanceador de carga no Amazon EC2. O balanceador de carga fornece um URL público voltado para a Internet e uma porta padrão (porta 80) que você pode usar para navegar até o link “Hello, World!” aplicativo.
A 'implantação' implanta três pods, e cada pod conterá um contêiner Docker com a mensagem 'Hello, World! ' aplicativo. Os três pods são implantados nos nós que foram criados quando você criou o cluster.

O manifesto neste tutorial é curto; no entanto, um manifesto pode incluir vários tipos de recursos do Kubernetes, como pods, trabalhos, entradas e políticas de rede. Além disso, você pode usar vários arquivos de manifesto se sua implantação for complexa.

Para adicionar um arquivo deployment.yaml

Emcodecatalyst-eks-source-repository, crie uma pasta chamadaKubernetes.

Em/Kubernetes, crie um arquivo chamado deployment.yaml com o seguinte conteúdo:


apiVersion: v1
kind: Service
metadata:
  name: my-service
  labels:
    app: my-app
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: codecatalyst-eks-container
        # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
        image: $REPOSITORY_URI:$IMAGE_TAG
        ports:
        - containerPort: 80

Adicione, confirme e envie:
```
git add .
git commit -m "add Kubernetes/deployment.yaml"
git push
```
O deployment.yaml arquivo é adicionado ao seu repositório em uma pasta chamadaKubernetes.

Agora você adicionou todos os seus arquivos de origem.

Reserve um momento para verificar seu trabalho e garantir que você tenha colocado todos os arquivos nas pastas corretas. A estrutura de pastas é a seguinte:


|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile

Etapa 5: criar AWS funções

Nesta seção, você cria funções AWS do IAM que seu CodeCatalyst fluxo de trabalho precisará para funcionar. Essas funções são:

Função de criação — concede permissão à ação de CodeCatalyst criação (no fluxo de trabalho) para acessar sua AWS conta e gravar no Amazon ECR e no Amazon EC2.
Função de implantação — concede à ação de cluster CodeCatalyst Deploy to Kubernetes (no fluxo de trabalho) permissão para acessar sua conta AWS e o Amazon EKS.

Para obter mais informações sobre as funções do IAM, consulte Funções do IAM no Guia AWS Identity and Access Management do usuário.

nota

Para economizar tempo, você pode criar uma única função, chamada de CodeCatalystWorkflowDevelopmentRole-spaceName função, em vez das duas funções listadas anteriormente. Para ter mais informações, consulte Criando a CodeCatalystWorkflowDevelopmentRole-spaceNamefunção para sua conta e espaço. Entenda que a CodeCatalystWorkflowDevelopmentRole-spaceName função tem permissões muito amplas que podem representar um risco de segurança. Recomendamos que você use essa função somente em tutoriais e cenários em que a segurança seja menos preocupante. Este tutorial pressupõe que você esteja criando as duas funções listadas anteriormente.

Para criar as funções de criação e implantação, conclua a série de procedimentos a seguir.

1. Para criar uma política de confiança para ambas as funções

Acesse seu ambiente de desenvolvimento.

No Cloud9-long-string diretório, crie um arquivo chamado codecatalyst-eks-trust-policy.json com o seguinte conteúdo:


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

2. Para criar a política de criação para a função de construção

No Cloud9-long-string diretório, crie um arquivo chamado codecatalyst-eks-build-policy.json com o seguinte conteúdo:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:*",
                "ec2:*"
            ],
            "Resource": "*"
        }
    ]
}
```
nota
Na primeira vez em que a função for usada para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e, em seguida, defina o escopo da política com o nome do recurso depois que ele estiver disponível.
```
"Resource": "*"
```

3. Para criar a política de implantação para a função de implantação

No Cloud9-long-string diretório, crie um arquivo chamado codecatalyst-eks-deploy-policy.json com o seguinte conteúdo:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "eks:DescribeCluster",
                "eks:ListClusters"
            ],
            "Resource": "*"
        }
    ]
}
```
nota
Na primeira vez em que a função for usada para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e, em seguida, defina o escopo da política com o nome do recurso depois que ele estiver disponível.
```
"Resource": "*"
```

Agora você adicionou três documentos de política ao seu ambiente de desenvolvimento. Sua estrutura de diretórios agora tem a seguinte aparência:


|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json

4. Para adicionar a política de compilação ao AWS

No terminal do Dev Environment, digite:
```
cd /projects
```

Digite:


aws iam create-policy \
    --policy-name codecatalyst-eks-build-policy \
    --policy-document file://codecatalyst-eks-build-policy.json

Pressione Enter.
Na saída do comando, observe o "arn": valor, por exemplo,arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy. Você precisará desse ARN mais tarde.

5. Para adicionar a política de implantação ao AWS

Digite:


aws iam create-policy \
    --policy-name codecatalyst-eks-deploy-policy \
    --policy-document file://codecatalyst-eks-deploy-policy.json

Pressione Enter.
Na saída do comando, observe o "arn": valor da política de implantação, por exemplo,arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy. Você precisará desse ARN mais tarde.

6. Para criar a função de criação

Digite:


aws iam create-role \
      --role-name codecatalyst-eks-build-role \
      --assume-role-policy-document file://codecatalyst-eks-trust-policy.json

Pressione Enter.
Digite:
```
aws iam attach-role-policy \
      --role-name codecatalyst-eks-build-role \
      --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy
```
Onde arn:aws:iam: :111122223333:policy/ é substituído pelo ARN da política codecatalyst-eks-build-policy de compilação que você observou anteriormente.
Pressione Enter.

No prompt do terminal, digite:


aws iam get-role \
      --role-name codecatalyst-eks-build-role

Pressione Enter.
Observe o "Arn": valor da função, por exemplo,arn:aws:iam::111122223333:role/codecatalyst-eks-build-role. Você precisará desse ARN mais tarde.

7. Para criar a função de implantação

Digite:


aws iam create-role \
      --role-name codecatalyst-eks-deploy-role \
      --assume-role-policy-document file://codecatalyst-eks-trust-policy.json

Pressione Enter.
Digite:
```
aws iam attach-role-policy \
      --role-name codecatalyst-eks-deploy-role \
      --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy
```
Onde arn:aws:iam: :111122223333:policy/ é substituído pelo ARN da política codecatalyst-eks-deploy-policy de implantação que você observou anteriormente.
Pressione Enter.

Digite:


aws iam get-role \
      --role-name codecatalyst-eks-deploy-role

Pressione Enter.
Observe o "Arn": valor da função, por exemplo,arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role. Você precisará desse ARN mais tarde.

Agora você criou funções de criação e implantação e anotou seus ARNs.

Etapa 6: Adicionar AWS funções a CodeCatalyst

Nesta etapa, você adiciona a função de criação (codecatalyst-eks-build-role) e a função de implantação (codecatalyst-eks-deploy-role) à Conta da AWS função conectada ao seu espaço. Isso torna as funções disponíveis para uso em seu fluxo de trabalho.

Para adicionar funções de criação e implantação ao seu Conta da AWS

No CodeCatalyst console, navegue até seu espaço.
Na parte superior, escolha Configurações.
No painel de navegação, escolha AWS contas. Uma lista de contas é exibida.
Na coluna Nome de CodeCatalyst exibição da Amazon, copie o nome de exibição de Conta da AWS onde você criou suas funções de criação e implantação. (Pode ser um número.) Você precisará desse valor posteriormente, ao criar seu fluxo de trabalho.
Escolha o nome de exibição.
Escolha Gerenciar funções no console de AWS gerenciamento.

A página Adicionar função do IAM ao CodeCatalyst espaço da Amazon é exibida. Talvez seja necessário fazer login para acessar a página.
Selecione Adicionar uma função existente que você criou no IAM.

Uma lista suspensa é exibida. A lista exibe as funções de criação e implantação e quaisquer outras funções do IAM com uma política de confiança que inclua os diretores de codecatalyst.amazonaws.com serviço codecatalyst-runner.amazonaws.com e os principais.
Na lista suspensa, adicione:
- codecatalyst-eks-build-role
- codecatalyst-eks-deploy-role
nota
Se você verThe security token included in the request is invalid, pode ser porque você não tem as permissões corretas. Para corrigir esse problema, saia e faça login novamente com a AWS conta que você usou ao criar seu CodeCatalyst espaço. AWS
Volte ao CodeCatalyst console e atualize a página.

As funções de criação e implantação agora devem aparecer em funções do IAM.

Essas funções agora estão disponíveis para uso em CodeCatalyst fluxos de trabalho.

Etapa 7: atualizar o ConfigMap

Você deve adicionar a função de implantação que você criou Etapa 5: criar AWS funções ao ConfigMap arquivo Kubernetes para dar à ação de cluster Implantar no Kubernetes (em seu fluxo de trabalho) a capacidade de acessar e interagir com seu cluster. Você pode usar eksctl ou kubectl para executar essa tarefa.

Para configurar o arquivo Kubernetes ConfigMap usando eksctl

No terminal do Dev Environment, digite:
```
eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
```
Em que:
- codecatalyst-eks-clusteré substituído pelo nome do cluster Amazon EKS.
- arn:aws:iam: :111122223333:role/ codecatalyst-eks-deploy-role é substituído pelo ARN da função de implantação que você criou em. Etapa 5: criar AWS funções
- codecatalyst-eks-deploy-role(ao lado de--username) é substituído pelo nome da função de implantação que você criou emEtapa 5: criar AWS funções.
  
  nota
  Se você decidiu não criar uma função de implantação, codecatalyst-eks-deploy-rolesubstitua pelo nome da CodeCatalystWorkflowDevelopmentRole-spaceName função. Para obter mais informações sobre essa função, consulte Etapa 5: criar AWS funções.
- us-west-2 é substituído por sua região.
Para obter detalhes sobre esse comando, consulte Gerenciar usuários e funções do IAM.

Uma mensagem semelhante à seguinte é exibida:
```
2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
```

Para configurar o arquivo Kubernetes ConfigMap usando kubectl

No terminal do Dev Environment, digite:
```
kubectl edit configmap -n kube-system aws-auth
```
O ConfigMap arquivo aparece na tela.

Adicione o texto em itálico vermelho:

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: v1
data:
  mapRoles: |
    - groups:
      - system:bootstrappers
      - system:nodes
      rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
      username: system:node:{{EC2PrivateDNSName}}
    - groups:
      - system:masters
      rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
      username: codecatalyst-eks-deploy-role
  mapUsers: |
    []
kind: ConfigMap
metadata:
  creationTimestamp: "2023-06-08T19:04:39Z"
  managedFields:
  ...

Em que:

arn:aws:iam: :111122223333:role/ codecatalyst-eks-deploy-role é substituído pelo ARN da função de implantação que você criou em. Etapa 5: criar AWS funções
codecatalyst-eks-deploy-role(ao lado deusername:) é substituído pelo nome da função de implantação que você criou emEtapa 5: criar AWS funções.

nota
Se você decidiu não criar uma função de implantação, codecatalyst-eks-deploy-rolesubstitua pelo nome da CodeCatalystWorkflowDevelopmentRole-spaceName função. Para obter mais informações sobre essa função, consulte Etapa 5: criar AWS funções.

Para obter detalhes, consulte Habilitar o acesso principal do IAM ao seu cluster no Guia do usuário do Amazon EKS.

Agora você concedeu à função de implantação e, por extensão, à ação Implantar no Amazon EKS, system:masters permissões para seu cluster Kubernetes.

Etapa 8: criar e executar um fluxo de trabalho

Nesta etapa, você cria um fluxo de trabalho que pega seus arquivos de origem, os transforma em uma imagem do Docker e, em seguida, implanta a imagem em pods de árvores no seu cluster Amazon EKS.

O fluxo de trabalho consiste nos seguintes blocos de construção que são executados sequencialmente:

Um gatilho — Esse gatilho inicia a execução automática do fluxo de trabalho quando você envia uma alteração ao seu repositório de origem. Para obter mais informações sobre gatilhos, consulte Iniciando um fluxo de trabalho executado automaticamente com gatilhos.
Uma ação de criação (BuildBackend) — No gatilho, a ação cria a imagem do Docker usando o Dockerfile e envia a imagem para o Amazon ECR. A ação de criação também atualiza $IMAGE_TAG as variáveis $REPOSITORY_URI e no deployment.yaml arquivo com os valores corretos e, em seguida, cria um artefato de saída desse arquivo e de quaisquer outros na Kubernetes pasta. Neste tutorial, o único arquivo na Kubernetes pasta édeployment.yaml, mas você pode incluir mais arquivos. O artefato é usado como entrada para a ação de implantação, que será a próxima.

Para obter mais informações sobre a ação de criação, consulteConstruindo com fluxos de trabalho.
Uma ação de implantação (DeployToEKS) — Ao concluir a ação de criação, a ação de implantação procura o artefato de saída gerado pela ação de construção (Manifests) e encontra o deployment.yaml arquivo dentro dela. Em seguida, a ação segue as instruções no deployment.yaml arquivo para executar três pods, cada um contendo um único “Hello, World!” Contêiner Docker — dentro do seu cluster Amazon EKS.

Para criar um fluxo de trabalho

Vá para o CodeCatalyst console.
Navegue até seu projeto (codecatalyst-eks-project).
No painel de navegação, escolha CI/CD e, em seguida, escolha Fluxos de trabalho.
Escolha Criar fluxo de trabalho.
Em Repositório de origem, escolhacodecatalyst-eks-source-repository.
Para Branch, escolhamain.
Escolha Criar.
Exclua o código de amostra YAML.

Adicione o código YAML a seguir para criar um novo arquivo de definição de fluxo de trabalho:

nota

Para obter mais informações sobre o arquivo de definição do fluxo de trabalho, consulteDefinição de fluxo de trabalho YAML.

nota

No código YAML a seguir, você pode omitir as Connections: seções se quiser. Se você omitir essas seções, deverá garantir que a função especificada no campo Função padrão do IAM em seu ambiente inclua as permissões e as políticas de confiança das duas funções descritas emEtapa 6: Adicionar AWS funções a CodeCatalyst. Para obter mais informações sobre como configurar um ambiente com uma função padrão do IAM, consulteCriar um ambiente.


Name: codecatalyst-eks-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  BuildBackend:
    Identifier: aws/build@v1
    Environment:
      Name: codecatalyst-eks-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-eks-build-role
    Inputs:
      Sources:
        - WorkflowSource
      Variables:
        - Name: REPOSITORY_URI
          Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo
        - Name: IMAGE_TAG
          Value: ${WorkflowSource.CommitId}
    Configuration:
      Steps:
        #pre_build:
        - Run: echo Logging in to Amazon ECR...
        - Run: aws --version
        - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
        #build:
        - Run: echo Build started on `date`
        - Run: echo Building the Docker image...
        - Run: docker build -t $REPOSITORY_URI:latest .
        - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
        #post_build:
        - Run: echo Build completed on `date`
        - Run: echo Pushing the Docker images...
        - Run: docker push $REPOSITORY_URI:latest
        - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
        # Replace the variables in deployment.yaml
        - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
        - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
        - Run: cat Kubernetes/*
        # The output artifact will be a zip file that contains Kubernetes manifest files.
    Outputs:
      Artifacts:
        - Name: Manifests
          Files: 
            - "Kubernetes/*"
  DeployToEKS:
    DependsOn: 
      - BuildBackend
    Identifier: aws/kubernetes-deploy@v1
    Environment:
      Name: codecatalyst-eks-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-eks-deploy-role
    Inputs:
      Artifacts:
        - Manifests
    Configuration:
      Namespace: default
      Region: us-west-2
      Cluster: codecatalyst-eks-cluster
      Manifests: Kubernetes/

No código anterior, substitua:

Ambas as instâncias de codecatalyst-eks-environmentcom o nome do ambiente em que você criouPré-requisitos.
Ambas as instâncias codecatalyst-account-connectioncom o nome de exibição da conexão da sua conta. O nome de exibição pode ser um número. Para ter mais informações, consulte Etapa 6: Adicionar AWS funções a CodeCatalyst.
codecatalyst-eks-build-rolecom o nome da função de construção em que você criouEtapa 5: criar AWS funções.
111122223333.dkr. ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo(na propriedadeValue:) com o URI do repositório Amazon ECR em que você criou. Etapa 3: Criar um repositório de imagens do Amazon ECR
111122223333.dkr. ecr.us-west-2.amazonaws.com (no comandoRun: aws ecr) com o URI do repositório Amazon ECR sem o sufixo da imagem (). /codecatalyst-eks-image-repo
codecatalyst-eks-deploy-rolecom o nome da função de implantação na qual você criouEtapa 5: criar AWS funções.
Ambas as instâncias de us-west-2 com AWS seu código de região. Para obter uma lista de códigos de região, consulte Endpoints regionais no Referência geral da AWS.

nota

Se você decidiu não criar e implantar funções, codecatalyst-eks-deploy-rolesubstitua codecatalyst-eks-build-rolee pelo nome da CodeCatalystWorkflowDevelopmentRole-spaceName função. Para obter mais informações sobre essa função, consulte Etapa 5: criar AWS funções.

(Opcional) Escolha Validar para garantir que o código YAML seja válido antes da confirmação.
Escolha Commit (Confirmar).
Na caixa de diálogo Confirmar fluxo de trabalho, insira o seguinte:
1. Em Confirmar mensagem, remova o texto e digite:
```
Add first workflow
```
2. Para Repositório, escolhacodecatalyst-eks-source-repository.
3. Em Nome da filial, escolha principal.
4. Escolha Commit (Confirmar).
Agora você criou um fluxo de trabalho. A execução de um fluxo de trabalho é iniciada automaticamente devido ao gatilho definido na parte superior do fluxo de trabalho. Especificamente, quando você confirmou (e enviou) o workflow.yaml arquivo ao seu repositório de origem, o gatilho iniciou a execução do fluxo de trabalho.

Para ver o progresso da execução do fluxo de trabalho

No painel de navegação do CodeCatalyst console, escolha CI/CD e, em seguida, escolha Fluxos de trabalho.
Escolha o fluxo de trabalho que você acabou de criar,codecatalyst-eks-workflow.
Escolha BuildBackendver o progresso da compilação.
Escolha DeployToEKS para ver o progresso da implantação.

Para obter mais informações sobre a visualização dos detalhes da execução, consulteVisualizando o status e os detalhes da execução do fluxo de trabalho.

Para verificar a implantação

Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.
À esquerda, na parte inferior, escolha Load Balancers.
Selecione o balanceador de carga que foi criado como parte da sua implantação do Kubernetes. Se você não tiver certeza de qual balanceador de carga escolher, procure as seguintes tags na guia Tags:
- kubernetes.io/service-name
- kubernetes.io/cluster/ekstutorialcluster
Com o balanceador de carga correto selecionado, escolha a guia Descrição.
Copie e cole o valor do nome DNS na barra de endereço do seu navegador.

O 'Hello, World! ' A página da web aparece em seu navegador, indicando que você implantou seu aplicativo com sucesso.

Etapa 9: faça uma alteração nos arquivos de origem

Nesta seção, você faz uma alteração no index.html arquivo no seu repositório de origem. Essa alteração faz com que o fluxo de trabalho crie uma nova imagem do Docker, marque-a com um ID de confirmação, envie-a para o Amazon ECR e a implemente no Amazon ECS.

Para alterar o index.html

Acesse seu ambiente de desenvolvimento.
No prompt do terminal, mude para seu repositório de origem:
```
cd /projects/codecatalyst-eks-source-repository
```
Obtenha as alterações mais recentes do fluxo de trabalho:
```
git pull
```
Abra o codecatalyst-eks-source-repository/public-html/index.html.
Na linha 14, altere o Hello, World! texto paraTutorial complete!.
Adicione, confirme e envie:
```
git add .
git commit -m "update index.html title"
git push
```
A execução de um fluxo de trabalho é iniciada automaticamente.
(Opcional) Digite:
```
git show HEAD
```
Anote o ID de confirmação da index.html alteração. Esse ID de confirmação será marcado na imagem do Docker que será implantada pela execução do fluxo de trabalho que você acabou de iniciar.
Assista ao progresso da implantação:
1. No CodeCatalyst console, no painel de navegação, escolha CI/CD e, em seguida, escolha Fluxos de trabalho.
2. Escolha codecatalyst-eks-workflow ver a última execução.
3. Escolha BuildBackende DeployToEKS para ver o progresso da execução do fluxo de trabalho.
Verifique se seu aplicativo foi atualizado, da seguinte forma:
1. Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.
2. À esquerda, na parte inferior, escolha Load Balancers.
3. Selecione o balanceador de carga que foi criado como parte da sua implantação do Kubernetes.
4. Copie e cole o valor do nome DNS na barra de endereço do seu navegador.
  
  O 'Tutorial concluído! ' A página da web aparece no seu navegador, indicando que você implantou com sucesso uma nova revisão do seu aplicativo.
(Opcional) Em AWS, alterne para o console do Amazon ECR e verifique se a nova imagem do Docker foi marcada com o ID de confirmação da etapa 7 deste procedimento.

Limpeza

Você deve limpar seu ambiente para não ser cobrado desnecessariamente pelos recursos de armazenamento e computação usados neste tutorial.

Para limpar

Exclua seu cluster:
1. No terminal do Dev Environment, digite:
```
eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
```
  Em que:
  - us-west-2 é substituído por sua região.
  - codecatalyst-eks-clusteré substituído pelo nome do cluster que você criou.
  Após 5 a 10 minutos, o cluster e os recursos associados são excluídos, incluindo, mas não se limitando a, AWS CloudFormation pilhas, grupos de nós (no Amazon EC2) e balanceadores de carga.
Importante
Se o eksctl delete cluster comando não funcionar, talvez seja necessário atualizar suas AWS credenciais ou suas kubectl credenciais. Se você não tiver certeza de quais credenciais atualizar, atualize as AWS credenciais primeiro. Para atualizar suas AWS credenciais, consulte. Como faço para corrigir os erros “Não é possível localizar credenciais” e ExpiredToken "”? Para atualizar suas kubectl credenciais, consulte. Como faço para corrigir os erros “Não é possível conectar-se ao servidor”?
No AWS console, limpe da seguinte forma:
1. No Amazon ECR, codecatalyst-eks-image-repo exclua.
2. No IAM Identity Center, exclua:
  1. codecatalyst-eks-user
  2. codecatalyst-eks-permission-set
3. No IAM, exclua:
  - codecatalyst-eks-build-role
  - codecatalyst-eks-deploy-role
  - codecatalyst-eks-build-policy
  - codecatalyst-eks-deploy-policy
No CodeCatalyst console, limpe da seguinte forma:
1. Excluircodecatalyst-eks-workflow.
2. Excluircodecatalyst-eks-environment.
3. Excluircodecatalyst-eks-source-repository.
4. Exclua seu ambiente de desenvolvimento.
5. Excluircodecatalyst-eks-project.

Neste tutorial, você aprendeu a implantar um aplicativo em um serviço Amazon EKS usando um CodeCatalyst fluxo de trabalho e uma ação de cluster Deploy to Kubernetes.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Implantação no Amazon EKS

Adicionando a ação “Implantar no cluster Kubernetes”