Implantação de uma workload de amostra do balanceador de carga no modo automático do EKS

Ajudar a melhorar esta página

Para contribuir com este guia de usuário, escolha o link Editar esta página no GitHub, disponível no painel direito de cada página.

Ajudar a melhorar esta página

Para contribuir com este guia de usuário, escolha o link Editar esta página no GitHub, disponível no painel direito de cada página.

Este guia orienta você na implantação de uma versão em contêiner do jogo 2048 no Amazon EKS, completa com balanceamento de carga e acessibilidade à internet.

Pré-requisitos

Etapa 1: criar o namespace

Primeiro, crie um namespace dedicado para a aplicação do jogo 2048.

Crie um arquivo chamado 01-namespace.yaml:

apiVersion: v1
kind: Namespace
metadata:
  name: game-2048

Aplique a configuração do namespace:

kubectl apply -f 01-namespace.yaml

Etapa 2: implantar uma aplicação

A aplicação executa várias réplicas do contêiner do jogo 2048.

Crie um arquivo chamado 02-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: game-2048
  name: deployment-2048
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  replicas: 5
  template:
    metadata:
      labels:
        app.kubernetes.io/name: app-2048
    spec:
      containers:
        - image: public.ecr.aws/l6m2t8p7/docker-2048:latest
          imagePullPolicy: Always
          name: app-2048
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: "0.5"

Principais componentes:

Aplique a implantação:

kubectl apply -f 02-deployment.yaml

Etapa 3: criar o serviço

O serviço expõe a implantação à rede do cluster.

Crie um arquivo chamado 03-service.yaml:

apiVersion: v1
kind: Service
metadata:
  namespace: game-2048
  name: service-2048
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: NodePort
  selector:
    app.kubernetes.io/name: app-2048

Principais componentes:

Aplique o serviço:

kubectl apply -f 03-service.yaml

Etapa 4: configurar o balanceamento de carga

Você vai configurar uma entrada para expor a aplicação à internet.

Primeiro, crie a IngressClass. Crie um arquivo chamado 04-ingressclass.yaml:

apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  namespace: game-2048
  labels:
    app.kubernetes.io/name: LoadBalancerController
  name: alb
spec:
  controller: eks.amazonaws.com/alb

Em seguida, crie o recurso Ingress. Crie um arquivo chamado 05-ingress.yaml:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: game-2048
  name: ingress-2048
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: service-2048
                port:
                  number: 80

Principais componentes:

Aplique as configurações de entrada:

kubectl apply -f 04-ingressclass.yaml
kubectl apply -f 05-ingress.yaml

Etapa 5: verificar a implantação

O campo ADDRESS na saída da entrada mostrará o endpoint do ALB. Aguarde de dois a três minutos para que o ALB provisione e registre todos os destinos.

Etapa 6: acessar o jogo

Abra seu navegador da Web e navegue até o URL do endpoint do ALB da etapa anterior. Você deve ver a interface do jogo 2048.

Etapa 7: limpeza

Para remover todos os recursos criados neste tutorial:

kubectl delete namespace game-2048

Isso excluirá todos os recursos no namespace, incluindo os recursos de implantação, serviço e entrada.

O que está acontece por detrás

Solução de problemas

Se o jogo não carregar: