Implantar e depure clusters do Amazon EKS - Recomendações da AWS
ResumoPré-requisitos e limitaçõesArquiteturaFerramentasÉpicosSolução de problemasRecursos relacionadosMais informações

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Implantar e depure clusters do Amazon EKS

Criado por Svenja Raether (AWS) e Mathew George (AWS)

Ambiente: PoC ou piloto

Tecnologias: contêineres e microsserviços; infraestrutura; modernização; tecnologia sem servidor; nativo de nuvem

Workload: todas as outras workloads

Serviços da AWS: Amazon EKS; AWS Fargate

Resumo

Os contêineres estão se tornando uma parte essencial do desenvolvimento de aplicativos nativos de nuvem. O Kubernetes fornece uma maneira eficiente de gerenciar e orquestrar contêineres. O Amazon Elastic Kubernetes Service (Amazon EKS) é um serviço totalmente gerenciado e certificado em conformidade com o Kubernetes para compilar, proteger, operar e manter clusters do Kubernetes na Amazon Web Services (AWS). Ele é compatível com a execução de pods no AWS Fargate para fornecer capacidade computacional sob demanda do tamanho certo.

É importante que desenvolvedores e administradores conheçam as opções de depuração ao executar workloads em contêineres. Este padrão orienta você na implantação e depuração de contêineres no Amazon EKS com o AWS Fargate. Isso inclui criar, implantar, acessar, depurar e limpar as workloads do Amazon EKS.

Pré-requisitos e limitações

Pré-requisitos

Limitações

  • Esse padrão fornece aos desenvolvedores práticas úteis de depuração para ambientes de desenvolvimento. Ele não indica as práticas recomendadas para ambientes de produção.

  • Se você estiver executando o Windows, use os comandos específicos do sistema operacional para definir as variáveis de ambiente.

Versões do produto usadas

Arquitetura

Pilha de tecnologia

  • Application Load Balancer

  • Amazon EKS

  • AWS Fargate

Arquitetura de destino

Todos os recursos mostrados no diagrama são provisionados usando comandos eksctl e kubectl emitidos de uma máquina local. Clusters privados devem ser executados a partir de uma instância que esteja dentro da VPC privada.

A arquitetura de destino consiste em um cluster EKS usando o tipo de inicialização Fargate. Ele fornece capacidade computacional sob demanda do tamanho certo, sem a necessidade de especificar tipos de servidor. O cluster EKS tem um ambiente de gerenciamento, que é usado para gerenciar os nós e as workloads do cluster. Os pods são provisionados em sub-redes VPC privadas que abrangem várias zonas de disponibilidade. A Galeria pública do Amazon ECR é referenciada para recuperar e implantar uma imagem do servidor web NGINX nos pods do cluster.

O diagrama mostra como acessar o ambiente de gerenciamento do Amazon EKS usando os comandos kubectl e como acessar o aplicativo usando o Application Load Balancer.

.

  1. Uma máquina local fora da Nuvem AWS envia comandos para o ambiente de gerenciamento do Kubernetes dentro de uma VPC gerenciada pelo Amazon EKS.

  2. O Amazon EKS agenda pods com base nos seletores no perfil do Fargate.

  3. A máquina local abre a URL do Application Load Balancer no navegador.

  4. O Application Load Balancer divide o tráfego entre os pods do Kubernetes nos nós do cluster Fargate implantados em sub-redes privadas abrangendo várias zonas de disponibilidade.

Ferramentas

Serviços da AWS

  • O Amazon Elastic Container Registry (Amazon ECR) é um serviço gerenciado de registro de imagens de contêineres seguro, escalável e confiável.

  • O Amazon Elastic Kubernetes Service (Amazon EKS) ajuda você a executar o Kubernetes na AWS sem precisar instalar e manter seus próprios nós ou ambiente de gerenciamento do Kubernetes. Esse padrão também usa a ferramenta de linha de comando eksctl para trabalhar com clusters Kubernetes no Amazon EKS.

  • O AWS Fargate ajuda a executar contêineres sem precisar gerenciar servidores ou instâncias do Amazon Elastic Compute Cloud (Amazon EC2). É usado em conjunto com o Amazon Elastic Container Service (Amazon ECS).

  • O Elastic Load Balancing (ELB) distribui o tráfego de entrada de aplicativos ou de rede em vários destinos. Por exemplo, você pode distribuir o tráfego entre instâncias, contêineres e endereços IP do Amazon Elastic Compute Cloud (Amazon EC2) em uma ou mais Zonas de disponibilidade. Esse padrão usa o componente de controle do AWS Load Balancer Controller para criar o Application Load Balancer quando uma entrada do Kubernetes é provisionada. O Application Load Balancer distribui o tráfego de entrada entre vários destinos.

Outras ferramentas

  • O Helm é um gerenciador de pacotes de código aberto para o Kubernetes. Nesse padrão, o Helm é usado para instalar o AWS Load Balancer Controller.

  • O Kubernetes é um sistema de código aberto para automatizar a implantação, a escalabilidade e o gerenciamento de aplicações em contêineres.

  • O NGINX é um servidor web e proxy reverso de alto desempenho.

Épicos

TarefaDescriçãoHabilidades necessárias

Criar os arquivos.

Usando o código na seção Informações adicionais, crie os seguintes arquivos:

  • clusterconfig-fargate.yaml

  • nginx-deployment.yaml

  • nginx-service.yaml

  • nginx-ingress.yaml

  • index.html

Desenvolvedor de aplicativos, administrador da AWS, AWS DevOps

Definição de variáveis de ambiente.

Observação: se um comando falhar devido a tarefas anteriores não concluídas, aguarde alguns segundos e execute o comando novamente.

Esse padrão usa a região da AWS e o nome do cluster definidos no arquivo clusterconfig-fargate.yaml. Defina os mesmos valores das variáveis de ambiente para referenciá-los em outros comandos.

export AWS_REGION="us-east-1"
export CLUSTER_NAME="my-fargate"
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Crie um cluster do EKS.

Para criar um cluster EKS que usa as especificações do arquivoclusterconfig-fargate.yaml, execute o comando a seguir.

eksctl create cluster -f clusterconfig-fargate.yaml

O arquivo contém ClusterConfig, que provisiona um novo cluster EKS chamado my-fargate-cluster na Região us-east-1 e um perfil Fargate padrão (fp-default).

O perfil Fargate padrão é configurado com dois seletores (default e kube-system).

Desenvolvedor de aplicativos, AWS DevOps, administrador da AWS

Verifique o cluster criado.

Para verificar o cluster criado, execute o seguinte comando.

eksctl get cluster --output yaml

A saída deve ser a seguinte.

- Name: my-fargate
  Owned: "True"
  Region: us-east-1

Verifique o perfil Fargate criado usando CLUSTER_NAME.

eksctl get fargateprofile --cluster $CLUSTER_NAME --output yaml

Esse comando exibe informações sobre os recursos. Você pode usar as informações para verificar o cluster criado. A saída deve ser a seguinte.

- name: fp-default
  podExecutionRoleARN: arn:aws:iam::<YOUR-ACCOUNT-ID>:role/eksctl-my-fargate-cluster-FargatePodExecutionRole-xxx
  selectors:
  - namespace: default
  - namespace: kube-system
  status: ACTIVE
  subnets:
  - subnet-aaa
  - subnet-bbb
  - subnet-ccc
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS
TarefaDescriçãoHabilidades necessárias

Implante o servidor web NGINX.

Para aplicar a implantação do servidor web NGINX no cluster, execute o comando a seguir.

kubectl apply -f ./nginx-deployment.yaml

A saída deve ser a seguinte.

deployment.apps/nginx-deployment created

A implantação inclui três réplicas da imagem do NGINX tiradas da Galeria pública do Amazon ECR. A imagem é implantada no namespace padrão e exposta na porta 80 nos pods em execução.

Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Verifique a implantação e os pods.

(Opcional) Verifique a implantação. Você pode verificar o status da implantação com o comando a seguir.

kubectl get deployment

A saída deve ser a seguinte.

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           7m14s

Um pod é um objeto implantável no Kubernetes, contendo um ou mais contêineres. Para listar todos os pods, execute o seguinte comando. 

kubectl get pods

A saída deve ser a seguinte.

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxxx-aaa   1/1     Running   0          94s
nginx-deployment-xxxx-bbb   1/1     Running   0          94s
nginx-deployment-xxxx-ccc   1/1     Running   0          94s
Desenvolvedor de aplicativos, AWS DevOps, administrador da AWS

Escale a implantação.

Para escalar a implantação das três réplicas especificadas em deployment.yaml para quatro réplicas, use o comando a seguir. 

kubectl scale deployment nginx-deployment --replicas 4

A saída deve ser a seguinte.

deployment.apps/nginx-deployment scaled
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS
TarefaDescriçãoHabilidades necessárias

Definição de variáveis de ambiente.

Descreva a CloudFormation pilha do cluster para recuperar informações sobre sua VPC.

aws cloudformation describe-stacks --stack-name eksctl-$CLUSTER_NAME-cluster --query "Stacks[0].Outputs[?OutputKey==\`VPC\`].OutputValue"

A saída deve ser a seguinte.

[
    "vpc-<YOUR-VPC-ID>"
]

Copie o ID da VPC e exporte-o como uma variável de ambiente.

export VPC_ID="vpc-<YOUR-VPC-ID>"
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Configurar o IAM para a conta de serviço do cluster.

Use o AWS_REGION e CLUSTER_NAME do épico anterior para criar um provedor IAM Open ID Connect para o cluster.

eksctl utils associate-iam-oidc-provider \
--region $AWS_REGION \
--cluster $CLUSTER_NAME \
--approve
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Faça download e crie a política do IAM.

Baixe a política do IAM para o Load Balancer Controller da AWS que permita que ele faça chamadas para APIs em seu nome.

curl -o iam-policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/main/docs/install/iam_policy.json

Crie a política em sua conta da AWS usando a CLI da AWS.

aws iam create-policy \
--policy-name AWSLoadBalancerControllerIAMPolicy \
--policy-document file://iam-policy.json

Você verá a saída a seguir.

{   
"Policy": {
       "PolicyName": "AWSLoadBalancerControllerIAMPolicy",
       "PolicyId": "<YOUR_POLICY_ID>",
       "Arn": "arn:aws:iam::<YOUR-ACCOUNT-ID>:policy/AWSLoadBalancerControllerIAMPolicy", 
       "Path": "/",
        "DefaultVersionId": "v1",
        "AttachmentCount": 0,
        "PermissionsBoundaryUsageCount": 0,
        "IsAttachable": true,
        "CreateDate": "<YOUR-DATE>",
        "UpdateDate": "<YOUR-DATE>"
   }
}

Salve o nome do recurso da Amazon (ARN) da política como $POLICY_ARN.

export POLICY_ARN=”arn:aws:iam::<YOUR-ACCOUNT-ID>:policy/AWSLoadBalancerControllerIAMPolicy”
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Crie uma conta de serviço do IAM.

Uma conta de serviço do IAM chamada aws-load-balancer-controller no namespace kube-system. Use CLUSTER_NAME, AWS_REGION e POLICY_ARN que você configurou anteriormente.

eksctl create iamserviceaccount \
--cluster=$CLUSTER_NAME \
--region=$AWS_REGION \
--attach-policy-arn=$POLICY_ARN \
--namespace=kube-system \
--name=aws-load-balancer-controller \
--override-existing-serviceaccounts \
--approve

Verifique a criação.

eksctl get iamserviceaccount \
--cluster $CLUSTER_NAME \
--name aws-load-balancer-controller \
--namespace kube-system \
--output yaml

A saída deve ser a seguinte.

- metadata:
    name: aws-load-balancer-controller
    namespace: kube-system
  status:
    roleARN: arn:aws:iam::<YOUR-ACCOUNT-ID>:role/eksctl-my-fargate-addon-iamserviceaccount-ku-Role1-<YOUR-ROLE-ID>
  wellKnownPolicies:
    autoScaler: false
    awsLoadBalancerController: false
    certManager: false
    ebsCSIController: false
    efsCSIController: false
    externalDNS: false
    imageBuilder: false
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Instale o Load Balancer Controller da AWS.

Atualize o repositório do Helm.

helm repo update

Adicione o repositório de gráficos do Amazon EKS ao repositório Helm. 

helm repo add eks https://aws.github.io/eks-charts

Aplique as definições de recursos personalizadas (CRDs) do Kubernetes que são usadas pelo eks-chart do AWS Load Balancer Controller em segundo plano.

kubectl apply -k "github.com/aws/eks-charts/stable/aws-load-balancer-controller//crds?ref=master"

A saída deve ser a seguinte.

customresourcedefinition.apiextensions.k8s.io/ingressclassparams.elbv2.k8s.aws created
customresourcedefinition.apiextensions.k8s.io/targetgroupbindings.elbv2.k8s.aws created

Instale o chart do Helm usando as variáveis de ambiente que você definiu anteriormente.

helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
 --set clusterName=$CLUSTER_NAME \
 --set serviceAccount.create=false \
 --set region=$AWS_REGION \
 --set vpcId=$VPC_ID \
 --set serviceAccount.name=aws-load-balancer-controller \
 -n kube-system

A saída deve ser a seguinte.

NAME: aws-load-balancer-controller
LAST DEPLOYED: <YOUR-DATE>
NAMESPACE: kube-system
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
AWS Load Balancer controller installed!
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Crie um serviço NGINX.

Crie um serviço para expor os pods do NGINX usando o arquivo nginx-service.yaml.

kubectl apply -f nginx-service.yaml

A saída deve ser a seguinte.

service/nginx-service created
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Crie o recurso de entrada do Kubernetes.

Crie um serviço para expor o ingresso dos Kubernetes do NGINX usando o arquivo nginx-ingress.yaml.

kubectl apply -f nginx-ingress.yaml

A saída deve ser a seguinte.

ingress.networking.k8s.io/nginx-ingress created
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Obtenha a URL do balanceador de carga.

Para recuperar as informações de entrada, use o comando a seguir.

kubectl get ingress nginx-ingress

A saída deve ser a seguinte.

NAME            CLASS    HOSTS   ADDRESS                                                                  PORTS   AGE
nginx-ingress   <none>   *       k8s-default-nginxing-xxx.us-east-1.elb.amazonaws.com   80      80s

Copie ADDRESS (por exemplo, k8s-default-nginxing-xxx.us-east-1.elb.amazonaws.com) da saída e cole-o em seu navegador para acessar o arquivo index.html.

Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS
TarefaDescriçãoHabilidades necessárias

Selecione um pod.

Liste todos os pods e copie o nome do pod desejado. 

kubectl get pods

A saída deve ser a seguinte.

NAME                               READY   STATUS    RESTARTS   AGE
nginx-deployment-xxxx-aaa      1/1     Running   0          55m
nginx-deployment-xxxx-bbb      1/1     Running   0          55m
nginx-deployment-xxxx-ccc      1/1     Running   0          55m
nginx-deployment-xxxx-ddd      1/1     Running   0          42m

Esse comando lista os pods existentes e as informações adicionais.

Se você estiver interessado em um pod específico, preencha o nome do pod em que você está interessado para a variável variável POD_NAME ou defina-o como uma variável de ambiente. Caso contrário, omita esse parâmetro para pesquisar todos os recursos.

export POD_NAME="nginx-deployment-<YOUR-POD-NAME>"
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Acesse os logs.

Obtenha os logs do pod que você deseja depurar.

kubectl logs $POD_NAME
Desenvolvedor de aplicativos, administrador de sistemas da AWS, AWS DevOps

Encaminhe a porta NGINX.

Use o encaminhamento de porta para mapear a porta do pod para acessar o servidor web NGINX em uma porta na sua máquina local.

kubectl port-forward deployment/nginx-deployment 8080:80

No seu navegador, abra o seguinte URL.

http://localhost:8080

O comando port-forward fornece acesso ao arquivo index.html sem disponibilizá-lo publicamente por meio de um balanceador de carga. Isso é útil para acessar o aplicativo em execução durante a depuração. Você pode interromper o encaminhamento de portas pressionando o comando do teclado Ctrl+C.

Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Execute comandos dentro do pod.

Para examinar o arquivo index.html atual, use o comando a seguir. 

kubectl exec $POD_NAME -- cat /usr/share/nginx/html/index.html

Você pode usar o comando exec para emitir qualquer comando diretamente no pod. Isso é útil para depurar os aplicativos em execução.

Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Copie arquivos para um pod.

Remova o arquivo index.html padrão desse pod.

kubectl exec $POD_NAME -- rm /usr/share/nginx/html/index.html

Faça o upload do arquivo local personalizado index.html para o pod.

kubectl cp index.html $POD_NAME:/usr/share/nginx/html/

Você pode usar o comando cp para alterar ou adicionar arquivos diretamente a qualquer um dos pods.

Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Use o encaminhamento de porta para exibir a alteração.

Use o encaminhamento de portas para verificar as alterações que você fez nesse pod.

kubectl port-forward pod/$POD_NAME 8080:80

Abra o seguinte URL no seu navegador.

http://localhost:8080

As alterações aplicadas ao arquivo index.html devem estar visíveis no navegador.

Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS
TarefaDescriçãoHabilidades necessárias

Exclui o balanceador de carga.

Exclua a entrada.

kubectl delete ingress/nginx-ingress

A saída deve ser a seguinte.

ingress.networking.k8s.io "nginx-ingress" deleted

Exclua o serviço.

kubectl delete service/nginx-service

A saída deve ser a seguinte.

service "nginx-service" deleted

Exclua o controlador do balanceador de carga.

helm delete aws-load-balancer-controller -n kube-system

A saída deve ser a seguinte.

release "aws-load-balancer-controller" uninstalled

Exclua a conta do serviço.

eksctl delete iamserviceaccount --cluster $CLUSTER_NAME --namespace kube-system --name aws-load-balancer-controller
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Exclua a implantação.

Para excluir os recursos de implantação, use o seguinte comando.

kubectl delete deploy/nginx-deployment

A saída deve ser a seguinte.

deployment.apps "nginx-deployment" deleted
Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Excluir o cluster.

Exclua o cluster EKS usando o comando a seguir, onde my-fargate é o nome do cluster.

eksctl delete cluster --name $CLUSTER_NAME

Esse comando exclui todo o cluster, incluindo todos os recursos associados.

Desenvolvedor de aplicativos, AWS DevOps, administrador de sistemas da AWS

Excluir a política do IAM.

Exclua a política criada anteriormente usando a CLI da AWS.

aws iam delete-policy --policy-arn $POLICY_ARN
Desenvolvedor de aplicativos, administrador da AWS, AWS DevOps

Solução de problemas

ProblemaSolução

Você recebe uma mensagem de erro na criação do cluster informando que sua zona de disponibilidade de destino não tem capacidade suficiente para oferecer suporte ao cluster. Você verá uma mensagem semelhante à mensagem abaixo.

Cannot create cluster 'my-fargate' because us-east-1e, the targeted availability zone, does not currently have sufficient capacity to support the cluster. Retry and choose from these availability zones: us-east-1a, us-east-1b, us-east-1c, us-east-1d, us-east-1f

Crie o cluster novamente usando as zonas de disponibilidade recomendadas a partir da mensagem de erro. Especifique uma lista de zonas de disponibilidade na última linha do seu arquivo clusterconfig-fargate.yaml (por exemplo, availabilityZones: ["us-east-1a", "us-east-1b", "us-east-1c"]).

Recursos relacionados

Mais informações

clusterconfig-fargate.yaml

apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: my-fargate
  region: us-east-1

fargateProfiles:
  - name: fp-default
    selectors:
      - namespace: default
      - namespace: kube-system

nginx-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: "nginx-deployment"
  namespace: "default"
spec:
  replicas: 3
  selector:
    matchLabels:
      app: "nginx"
  template:
    metadata:
      labels:
        app: "nginx"
    spec:
      containers:
      - name: nginx
        image: public.ecr.aws/nginx/nginx:latest  
        ports:
        - containerPort: 80

nginx-service.yaml

apiVersion: v1
kind: Service
metadata:
  annotations:
    alb.ingress.kubernetes.io/target-type: ip
  name: "nginx-service"
  namespace: "default"
spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  type: NodePort
  selector:
    app: "nginx"

nginx-ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: "default"
  name:  "nginx-ingress"
  annotations:
    kubernetes.io/ingress.class: alb
    alb.ingress.kubernetes.io/scheme: internet-facing
spec:
  rules:
    - http:
        paths:
        - path: /
          pathType: Prefix
          backend:
            service:
              name: "nginx-service"
              port:
                number: 80

index.html

<!DOCTYPE html>
<html>

<body>
    <h1>Welcome to your customized nginx!</h1>
    <p>You modified the file on this running pod</p>
</body>

</html>