**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.
# Inicio rápido: implementación de una aplicación web y almacenamiento de datos
Este tutorial de inicio rápido lo guía por los pasos que se deben seguir para implementar la aplicación de muestra del videojuego 2048 y conservar sus datos en un clúster del modo automático de Amazon EKS mediante [eksctl](https://eksctl.io/).
El [modo automático de Amazon EKS](automode.md) simplifica la administración de clústeres mediante la automatización de tareas rutinarias como el almacenamiento en bloques, las redes, el equilibrio de carga y el escalado automático de computación. Durante la configuración, gestiona la creación de nodos con instancias administradas de EC2, equilibradores de carga de aplicación y volúmenes de EBS.
En resumen, implementará un ejemplo de carga de trabajo con las anotaciones personalizadas necesarias para una integración sin problemas con los servicios de AWS.
## En este tutorial:
Utilizará la plantilla del clúster de `eksctl` que aparece a continuación para crear un clúster con el modo automático de EKS para el aprovisionamiento automatizado de nodos.
+ **Configuración de la VPC**: al utilizar la plantilla del clúster de eksctl que aparece a continuación, eksctl crea automáticamente una nube privada virtual (VPC) IPv4 para el clúster. De forma predeterminada, eksctl configura una VPC que aborda todos los requisitos de red, además de crear puntos de conexión públicos y privados.
+ **Administración de instancias**: el modo automático de EKS agrega o elimina nodos dinámicamente en el clúster de EKS en función de la demanda de las aplicaciones de Kubernetes.
+ **Persistencia de los datos**: utilice la capacidad de almacenamiento en bloques del modo automático de EKS para garantizar la persistencia de los datos de la aplicación, incluso en situaciones en las que el pod se reinicie o se produzca un error.
+ **Acceso a aplicaciones externas**: utilice la capacidad de equilibrio de carga del modo automático de EKS para aprovisionar dinámicamente un equilibrador de carga de aplicación (ALB).
## Requisitos previos
Antes de comenzar, asegúrese de haber realizado las siguientes tareas:
+ [Configuración de su entorno para Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/setting-up.html)
+ [Instalación de la versión más reciente de eksctl](https://eksctl.io/installation/)
## Configuración del clúster
En esta sección, creará un clúster mediante el modo automático de EKS para el aprovisionamiento dinámico de nodos.
Cree un archivo denominado `cluster-config.yaml` y pegue en él el siguiente contenido. Sustituya `region-code` por una región válida (por ejemplo, `us-east-1`).
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: web-quickstart
region:
autoModeConfig:
enabled: true
```
Ahora, estamos listos para crear el clúster.
Cree el clúster de EKS con mediante `cluster-config.yaml``:
```
eksctl create cluster -f cluster-config.yaml
```
**importante**
Si no usa eksctl para crear el clúster, debe etiquetar manualmente las subredes de la VPC.
## Cree la IngressClass
Cree una `IngressClass` de Kubernetes para el modo automático de EKS. La IngressClass define cómo el modo automático de EKS gestiona los recursos de ingreso. En este paso se configura la capacidad de equilibrio de carga del modo automático de EKS. Al crear recursos de ingreso para las aplicaciones, el modo automático de EKS utiliza esta IngressClass para aprovisionar y administrar automáticamente los equilibradores de carga, con lo que integra las aplicaciones de Kubernetes con los servicios de equilibrio de carga de AWS.
Guarde el siguiente archivo 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 la IngressClass al clúster:
```
kubectl apply -f ingressclass.yaml
```
## Implemente la aplicación de muestra del videojuego 2048
En esta sección, explicamos los pasos para implementar el popular “juego 2048” como una aplicación de muestra dentro del clúster. El manifiesto proporcionado incluye anotaciones personalizadas para el equilibrador de carga de aplicación (ALB). Estas anotaciones se integran con EKS y le indican que gestione el tráfico HTTP entrante como “orientado a Internet” y lo dirija al servicio correspondiente en el espacio de nombres `game-2048` mediante el tipo de destino “ip”.
**nota**
La imagen `docker-2048` del ejemplo es una imagen de contenedor `x86_64` y no se ejecutará en otras arquitecturas.
1. Cree un espacio de nombres de Kubernetes llamado `game-2048` con la marca `--save-config`.
```
kubectl create namespace game-2048 --save-config
```
Debería ver la siguiente respuesta de salida:
```
namespace/game-2048 created
```
1. Implemente la [aplicación de ejemplo del juego 2048](https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml).
```
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
```
Este manifiesto configura una implementación, un servicio y una entrada de Kubernetes para el espacio de nombres `game-2048`, lo que crea los recursos necesarios para implementar y exponer la aplicación de `game-2048` dentro del clúster. Incluye la creación de un servicio denominado `service-2048` que expone la implementación en el puerto `80` y un recurso Ingress denominado `ingress-2048` que define las reglas de enrutamiento para el tráfico HTTP entrante y las anotaciones para un equilibrador de carga de aplicaciones (ALB) con acceso a Internet. Debería ver la siguiente respuesta de salida:
```
namespace/game-2048 configured
deployment.apps/deployment-2048 created
service/service-2048 created
ingress.networking.k8s.io/ingress-2048 created
```
1. Ejecute el siguiente comando para obtener el recurso Ingress para el espacio de nombres `game-2048`.
```
kubectl get ingress -n game-2048
```
Debería ver la siguiente respuesta de salida:
```
NAME CLASS HOSTS ADDRESS PORTS AGE
ingress-2048 alb * k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com 80 31s
```
Deberá esperar varios minutos para que el equilibrador de carga de aplicación (ALB) se aprovisione antes de comenzar con los siguientes pasos.
1. Abra un navegador web y escriba la `ADDRESS` del paso anterior para acceder a la aplicación web. Por ejemplo:
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Debería ver el juego 2048 en el navegador. Juegue.
![\[Jugar a 2048\]](http://docs.aws.amazon.com/es_es/eks/latest/userguide/images/quick2048.png)
## Conservación de los datos con el modo automático de Amazon EKS
Ahora que el videojuego 2048 se encuentra en funcionamiento en el clúster de Amazon EKS, es hora de asegurarse de que los datos del videojuego se conservan de forma segura mediante la capacidad de almacenamiento en bloque del modo automático de Amazon EKS.
1. Cree un archivo denominado `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"
```
1. Aplicación de `StorageClass`:
```
kubectl apply -f storage-class.yaml
```
1. Cree una reclamación de volumen persistente (PVC) para solicitar el almacenamiento de los datos de su juego. Cree un archivo llamado `ebs-pvc.yaml` y agregue el siguiente contenido:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: game-data-pvc
namespace: game-2048
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi
storageClassName: auto-ebs-sc
```
1. Aplique el PVC en su clúster:
```
kubectl apply -f ebs-pvc.yaml
```
Debería ver la siguiente respuesta de salida:
```
persistentvolumeclaim/game-data-pvc created
```
1. Ahora, tiene que actualizar la implementación del juego 2048 para usar este PVC para almacenar datos. La siguiente implementación está configurada para usar el PVC para almacenar los datos del juego. Cree un archivo llamado `ebs-deployment.yaml` que contenga lo siguiente:
```
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
```
1. Aplique la implementación actualizada:
```
kubectl apply -f ebs-deployment.yaml
```
Debería ver la siguiente respuesta de salida:
```
deployment.apps/deployment-2048 configured
```
Tras seguir estos pasos, el videojuego 2048 deberá estar configurado en el clúster para conservar los datos mediante la capacidad de almacenamiento en bloque del modo automático de Amazon EKS. Esto garantiza que el progreso y los datos del juego estén seguros incluso en caso de que se produzca un fallo en el pod o en el nodo.
Si le ha gustado este tutorial, envíenos sus comentarios para que podamos ofrecerle más tutoriales de inicio rápido específicos para cada caso práctico, como este.
## Limpieza
Para evitar incurrir en cargos futuros, debe eliminar manualmente la pila de CloudFormation asociada para borrar todos los recursos creados durante esta guía, incluida la red de la VPC.
Elimine la pila de CloudFormation:
```
eksctl delete cluster -f ./cluster-config.yaml
```