**Ayude a mejorar esta página**
Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.
# Implementación de una carga de trabajo de equilibrador de carga de muestra en el modo automático de EKS
En esta guía se explica cómo implementar una versión en contenedores del videojuego 2048 en Amazon EKS, con equilibrio de carga y accesibilidad a Internet.
## Requisitos previos
+ Un clúster de modo automático de EKS
+ `kubectl` configurado para interactuar con el clúster
+ Permisos de IAM adecuados para crear recursos del equilibrador de carga de aplicaciones
## Paso 1: Creación del espacio de nombres
En primer lugar, cree un espacio de nombres dedicado para la aplicación del videojuego 2048.
Cree un archivo denominado `01-namespace.yaml`:
```
apiVersion: v1
kind: Namespace
metadata:
name: game-2048
```
Aplique la configuración del espacio de nombres:
```
kubectl apply -f 01-namespace.yaml
```
## Paso 2: Implementación de la aplicación
La aplicación ejecuta varias réplicas del contenedor del videojuego 2048.
Cree un archivo denominado `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"
```
**nota**
Si obtiene un error al cargar la imagen `public.ecr.aws/l6m2t8p7/docker-2048:latest`, confirme que el rol de IAM del nodo tenga los permisos suficientes para extraer imágenes de ECR. Para obtener más información, consulte [Rol de IAM de nodo](auto-learn-iam.md#auto-learn-node-iam-role). Además, la imagen `docker-2048` del ejemplo es una imagen `x86_64` y no se ejecutará en otras arquitecturas.
**Componentes principales:**
+ Implementa 5 réplicas de la aplicación
+ Utiliza una imagen de ECR pública
+ Solicita 0,5 núcleos de CPU por pod
+ Expone el puerto 80 para el tráfico HTTP
Aplique la implementación:
```
kubectl apply -f 02-deployment.yaml
```
## Paso 3: Creación del servicio
El servicio expone la implementación a la red del clúster.
Cree un archivo denominado `03-service.yaml`:
```
apiVersion: v1
kind: Service
metadata:
namespace: game-2048
name: service-2048
spec:
ports:
- port: 80
targetPort: 80
protocol: TCP
selector:
app.kubernetes.io/name: app-2048
```
**Componentes principales:**
+ Crea un servicio NodePort
+ Asigna el puerto 80 al puerto 80 del contenedor
+ Utiliza el selector de etiquetas para encontrar pods
Aplique el servicio:
```
kubectl apply -f 03-service.yaml
```
## Paso 4: Configuración del equilibrio de carga
Configurará un ingreso para exponer la aplicación a Internet.
Primero, cree la `IngressClass`. Cree un archivo denominado `04-ingressclass.yaml`:
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
labels:
app.kubernetes.io/name: LoadBalancerController
name: alb
spec:
controller: eks.amazonaws.com/alb
```
**nota**
El modo automático de EKS requiere etiquetas de subred para identificar las subredes públicas y privadas.
Si creó el clúster con `eksctl`, ya dispone de estas etiquetas.
Aprenda cómo [Etiquetado de subredes para el modo automático de EKS](tag-subnets-auto.md).
A continuación, cree el recurso de ingreso. Cree un archivo denominado `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
```
**Componentes principales:**
+ Creación de un equilibrador de carga de aplicaciones expuesto a Internet
+ Utiliza el tipo de destino de IP para el enrutamiento directo de pods
+ Dirige todo el tráfico (/) al servicio del videojuego
Aplique las configuraciones de ingreso:
```
kubectl apply -f 04-ingressclass.yaml
kubectl apply -f 05-ingress.yaml
```
## Paso 5: Verificación de la implementación
1. Compruebe que todos los pods estén en ejecución:
```
kubectl get pods -n game-2048
```
1. Compruebe que el servicio se haya creado:
```
kubectl get svc -n game-2048
```
1. Obtenga el punto de conexión del equilibrador de carga de aplicaciones:
```
kubectl get ingress -n game-2048
```
El campo ADDRESS en la salida del ingreso mostrará el punto de conexión del equilibrador de carga de aplicaciones. Espere de 2 a 3 minutos para que el equilibrador de carga de aplicaciones aprovisione y registre todos los destinos.
## Paso 6: Acceso al videojuego
Abra el navegador web y vaya a la URL del punto de conexión del equilibrador de carga de aplicaciones del paso anterior. Aparecerá la interfaz del videojuego 2048.
## Paso 7: Efectúe una limpieza
Para eliminar todos los recursos creados en este tutorial:
```
kubectl delete namespace game-2048
```
Esto eliminará todos los recursos del espacio de nombres, incluidos los recursos de implementación, servicio e ingreso.
## Lo que ocurre detrás de las cámaras
1. La implementación crea 5 pods que ejecutan el videojuego 2048
1. El servicio proporciona un acceso de red estable a estos pods
1. Modo automático de EKS:
+ Crea un equilibrador de carga de aplicación en AWS
+ Configura grupos de destino para los pods
+ Establece reglas de enrutamiento para dirigir el tráfico al servicio
## Solución de problemas
Si el videojuego no se carga
+ Asegúrese de que todos los pods se ejecutan: `kubectl get pods -n game-2048`
+ Compruebe el estado del ingreso: `kubectl describe ingress -n game-2048`
+ Verifique las comprobaciones de estado del equilibrador de carga de aplicación: compruebe el estado del grupo de destino en la Consola de AWS