Neste tutorial Pré-requisitos Configurar o cluster Criar IngressClass Implantar a aplicação de exemplo do jogo 2048 Persistir dados usando o Modo Automático do Amazon EKS Limpeza

Início rápido: implantar uma aplicação Web e armazenar dados

Este tutorial de início rápido orienta como implantar a aplicação de amostra do jogo 2048 e manter seus dados em um cluster do modo automático do Amazon EKS, usando o eksctl.

Com o modo automático do Amazon EKS, o gerenciamento de clusters se torna mais simples, pois tarefas rotineiras como armazenamento em bloco, rede, balanceamento de carga e ajuste de escala automático de computação são automatizadas. Durante a configuração, ele gerencia a criação de nós com instâncias gerenciadas do EC2, balanceadores de carga de aplicações e volumes do EBS.

Em resumo, você implantará uma workload de amostra, incluindo as anotações personalizadas exigidas para que a integração com os serviços da AWS ocorra de forma perfeita.

Neste tutorial

Usando o modelo de cluster do eksctl a seguir, você criará um cluster com o Modo Automático do EKS para provisionamento automatizado de nós.

Configuração da VPC: ao usar o modelo de cluster do eksctl apresentado a seguir, o eksctl cria automaticamente uma nuvem privada virtual (VPC) IPv4 para o cluster. Por padrão, o eksctl configura uma VPC que atende a todos os requisitos de rede, além de criar endpoints públicos e privados.
Gerenciamento de instâncias O modo automático do EKS adiciona ou remove nós dinamicamente no cluster do EKS com base nas demandas das aplicações do Kubernetes.
Persistência de dados use a funcionalidade de armazenamento em blocos do modo automático do EKS para garantir a persistência dos dados da aplicação, mesmo em cenários que envolvam reinicializações ou falhas de pods.
Acesso externo à aplicação use a funcionalidade de balanceamento de carga do modo automático do EKS para provisionar dinamicamente um Application Load Balancer (ALB).

Pré-requisitos

Antes de começar, certifique-se de ter realizado as seguintes tarefas:

Configurar o cluster

Nesta seção, você criará um cluster usando o Modo Automático do EKS para o provisionamento dinâmico de nós.

Crie um arquivo cluster-config.yaml e cole o conteúdo a seguir nele. Substitua region-code por uma região válida (por exemplo, us-east-1).


apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: web-quickstart
  region: <region-code>

autoModeConfig:
  enabled: true

Agora, estamos prontos para criar o cluster.

Crie o cluster EKS usando o cluster-config.yaml`:


eksctl create cluster -f cluster-config.yaml

Importante

Caso não use o eksctl para criar o cluster, você precisará marcar manualmente as sub-redes da VPC.

Criar IngressClass

Crie uma IngressClass do Kubernetes para o Modo Automático do EKS. A IngressClass define como o Modo Automático do EKS lida com os recursos de entrada. Esta etapa configura a capacidade de balanceamento de carga do Modo Automático do EKS. Quando você cria recursos de entrada para as aplicações, o Modo Automático do EKS usa essa IngressClass para provisionar e gerenciar automaticamente balanceadores de carga, integrando as aplicações do Kubernetes aos serviços de balanceamento de carga da AWS.

Salve o seguinte arquivo yaml como ingressclass.yaml:


apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: alb
  annotations:
    ingressclass.kubernetes.io/is-default-class: "true"
spec:
  controller: eks.amazonaws.com/alb

Aplique a IngressClass ao cluster:


kubectl apply -f ingressclass.yaml

Implantar a aplicação de exemplo do jogo 2048

Nesta seção, mostraremos as etapas para implantar o popular “jogo 2048” como uma aplicação de amostra no cluster. O manifesto fornecido inclui anotações personalizadas para o Application Load Balancer (ALB). Essas anotações se integram ao EKS e instruem o serviço a tratar o tráfego HTTP recebido como “exposto à internet” e direcioná-lo para o serviço apropriado no namespace game-2048, usando o tipo de destino “ip”.

nota

A imagem docker-2048 no exemplo é uma imagem de contêiner x86_64 e não será executada em outras arquiteturas.

Crie um namespace do Kubernetes denominado game-2048 com o sinalizador --save-config.
```
kubectl create namespace game-2048 --save-config
```
Você verá a seguinte saída de resposta:
```
namespace/game-2048 created
```
Implante a aplicação de amostra do jogo 2048.
```
kubectl apply -n game-2048 -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml
```
Esse manifesto configura uma implantação, um serviço e uma entrada do Kubernetes para o namespace game-2048, criando os recursos necessários para implantar e expor a aplicação game-2048 no cluster. Isso inclui a criação de um serviço denominado service-2048 que expõe a implantação na porta 80 e um recurso de entrada denominado ingress-2048 que define regras de roteamento para tráfego HTTP de entrada e anotações para um Application Load Balancer (ALB) voltado para a internet. Você verá a seguinte saída de resposta:
```
namespace/game-2048 configured
deployment.apps/deployment-2048 created
service/service-2048 created
ingress.networking.k8s.io/ingress-2048 created
```

Execute o comando a seguir para obter o recurso de entrada para o namespace game-2048.


kubectl get ingress -n game-2048

Você verá a seguinte saída de resposta:


NAME           CLASS   HOSTS   ADDRESS                                                                    PORTS   AGE
ingress-2048   alb     *       k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com   80      31s

Você precisará esperar alguns minutos para que o Application Load Balancer (ALB) seja provisionado antes de começar as etapas a seguir.

Abra o navegador da Web e digite o ADDRESS da etapa anterior para acessar a aplicação Web. Por exemplo:
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Você deve ver o jogo 2048 no seu navegador. Reproduza.

Persistir dados usando o Modo Automático do Amazon EKS

Agora que o jogo 2048 está instalado e em execução no cluster do Amazon EKS, é hora de garantir que os dados do jogo sejam persistidos com segurança usando o recurso de armazenamento em blocos do Modo Automático do Amazon EKS.

Crie um arquivo chamado storage-class.yaml:


apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: auto-ebs-sc
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: ebs.csi.eks.amazonaws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
  type: gp3
  encrypted: "true"

Aplique a StorageClass:
```
kubectl apply -f storage-class.yaml
```

Crie uma solicitação de volume persistente (PVC) para solicitar armazenamento para os dados do seu jogo. Crie um arquivo denominado ebs-pvc.yaml e adicione o seguinte conteúdo a ele:


apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: game-data-pvc
  namespace: game-2048
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: auto-ebs-sc

Aplique a PVC ao cluster:


kubectl apply -f ebs-pvc.yaml

Você verá a seguinte saída de resposta:


persistentvolumeclaim/game-data-pvc created

Você agora precisa atualizar a implantação do jogo 2048 para usar essa PVC para armazenar dados. A implantação a seguir está configurada para usar a PVC para armazenar dados do jogo. Crie um arquivo denominado ebs-deployment.yaml e adicione o seguinte conteúdo a ele:


apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: game-2048
  name: deployment-2048
spec:
  replicas: 3  # Adjust the number of replicas as needed
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  template:
    metadata:
      labels:
        app.kubernetes.io/name: app-2048
    spec:
      containers:
        - name: app-2048
          image: public.ecr.aws/l6m2t8p7/docker-2048:latest
          imagePullPolicy: Always
          ports:
            - containerPort: 80
          volumeMounts:
            - name: game-data
              mountPath: /var/lib/2048
      volumes:
        - name: game-data
          persistentVolumeClaim:
            claimName: game-data-pvc

Aplique a implantação atualizada:


kubectl apply -f ebs-deployment.yaml

Você verá a seguinte saída de resposta:


deployment.apps/deployment-2048 configured

Com essas etapas, o jogo 2048 no cluster agora está configurado para persistir os dados usando o recurso de armazenamento em blocos do Modo Automático do Amazon EKS. Isso garante que o progresso e os dados do jogo estejam seguros mesmo no caso de falhas nos pods ou nós.

Caso tenha gostado deste tutorial, deixe seu feedback para que possamos fornecer mais tutoriais de início rápido específicos para casos de uso, como este.

Limpeza

Para evitar cobranças futuras, você precisará excluir manualmente a pilha associada do CloudFormation para excluir todos os recursos criados durante este guia, incluindo a rede VPC.

Exclua a pilha do CloudFormation:


eksctl delete cluster -f ./cluster-config.yaml

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

Configuração do kubectl e eksctl

Conhecer o Amazon EKS