AWS Review
English

Appearance

On this page

Ejercicio: Implementación de PrestaShop en AWS con EKS, EFS, Aurora, Memcached, WAF y Múltiples Entornos ​

Descripción del Escenario ​

Desplegarás una instancia de PrestaShop en un clúster EKS en AWS con almacenamiento compartido en EFS, base de datos Aurora MySQL y caché en Memcached. También, implementarás AWS WAF para proteger la aplicación contra amenazas comunes y configuraremos tres entornos: DEV (Desarrollo), STG (Staging) y PROD (Producción). Este proyecto sigue prácticas recomendadas para aplicaciones de e-commerce en la nube, facilitando el ciclo de vida de desarrollo, pruebas y despliegue.

Estructura del Directorio ​

plaintext
prestashop-aws/
├── cloudformation/
│   ├── eks-cluster.yaml                  # Configuración de clúster EKS
│   ├── efs.yaml                          # Configuración de EFS
│   ├── aurora-mysql.yaml                 # Configuración de Aurora MySQL
│   ├── memcached.yaml                    # Configuración de Memcached
│   ├── waf.yaml                          # Configuración de WAF para proteger el tráfico entrante
│   └── roles/                            # Roles de IAM y permisos necesarios
│       ├── eks-role.yaml                 # Permisos de EKS
│       └── efs-role.yaml                 # Permisos de EFS
├── k8s/
│   ├── deployments/
│   │   ├── dev/                          # Configuración de despliegue para DEV
│   │   │   └── prestashop.yaml
│   │   ├── stg/                          # Configuración de despliegue para STG
│   │   │   └── prestashop.yaml
│   │   └── prod/                         # Configuración de despliegue para PROD
│   │       └── prestashop.yaml
│   ├── services/
│   │   ├── prestashop-svc.yaml           # Servicio para exponer PrestaShop
│   │   └── efs-svc.yaml                  # Servicio para el sistema de archivos EFS
│   ├── configmaps/
│   │   └── prestashop-configmap.yaml     # Configuración de PrestaShop
│   └── secrets/
│       └── db-credentials.yaml           # Secretos de credenciales de la base de datos
├── environments/
│   ├── dev/                              # Scripts específicos para el entorno de desarrollo
│   │   ├── create-cluster.sh
│   │   ├── deploy-prestashop.sh
│   │   └── teardown.sh
│   ├── stg/                              # Scripts específicos para el entorno de staging
│   │   ├── create-cluster.sh
│   │   ├── deploy-prestashop.sh
│   │   └── teardown.sh
│   └── prod/                             # Scripts específicos para el entorno de producción
│       ├── create-cluster.sh
│       ├── deploy-prestashop.sh
│       └── teardown.sh
└── README.md                             # Documentación del proyecto

Etapas del Ejercicio ​

Etapa 1: Configuración del Entorno ​

  1. Instala y configura el CLI de AWS y kubectl.
  2. Crea roles de IAM con permisos específicos para cada servicio (EKS, EFS, WAF) en la carpeta cloudformation/roles.
  3. Documenta las configuraciones iniciales y los entornos en README.md.

Etapa 2: Configuración de Clústeres EKS para Múltiples Entornos (DEV, STG, PROD) ​

  1. Para cada entorno (DEV, STG, PROD), despliega un clúster EKS mediante el archivo eks-cluster.yaml o utilizando eksctl.
  2. Configura el contexto de kubectl para cada entorno, asegurando que puedes alternar entre ellos.
  3. Documenta el acceso a los entornos en el README.md.

Etapa 3: Implementación de EFS para Almacenamiento Compartido ​

  1. Crea un sistema de archivos EFS para cada entorno mediante efs.yaml.
  2. Configura un Access Point para cada entorno, facilitando el acceso desde Kubernetes.
  3. Define un StorageClass en Kubernetes para conectar los pods de PrestaShop con el almacenamiento compartido.
  4. Configura reglas de seguridad de acuerdo con el entorno y la aplicación.

Etapa 4: Configuración de Aurora MySQL ​

  1. Despliega un clúster de Aurora MySQL para cada entorno usando aurora-mysql.yaml.
  2. Crea secretos en Kubernetes (db-credentials.yaml) para almacenar las credenciales de conexión de la base de datos en cada entorno.
  3. Verifica la conectividad desde cada clúster de EKS a su respectivo clúster de Aurora.

Etapa 5: Configuración de Memcached ​

  1. Configura Memcached en cada entorno usando el archivo memcached.yaml.
  2. Implementa un servicio interno en Kubernetes para cada instancia de Memcached (memcached-svc.yaml).
  3. Actualiza la configuración de PrestaShop para utilizar Memcached como caché de objetos en cada entorno.

Etapa 6: Configuración y Protección con AWS WAF ​

  1. Implementa un AWS WAF mediante el archivo waf.yaml.
  2. Configura reglas de protección básicas contra SQL Injection, XSS y Limitación de IP.
  3. Asocia el WAF al balanceador de carga público en cada entorno para proteger PrestaShop de ataques comunes.
  4. Documenta las reglas de WAF aplicadas en README.md.

Etapa 7: Despliegue de PrestaShop en Kubernetes ​

  1. Para cada entorno, crea archivos de despliegue (prestashop.yaml) en las carpetas dev, stg y prod dentro de deployments/.
  2. Configura PrestaShop para utilizar EFS como almacenamiento, Aurora como base de datos y Memcached como caché en cada entorno.
  3. Despliega PrestaShop en cada clúster EKS y verifica el estado de los pods.
  4. Documenta el despliegue de cada entorno y su configuración.

Etapa 8: Configuración de Servicios y Exposición ​

  1. Crea un servicio LoadBalancer en cada entorno para exponer PrestaShop al público (prestashop-svc.yaml).
  2. Configura el balanceador de carga y el WAF para cada entorno, asegurando tráfico en el puerto 80 o 443.
  3. Prueba la conectividad en cada entorno y documenta las URLs de acceso en el README.md.

Etapa 9: Pruebas, Validación y Optimización ​

  1. Realiza pruebas de carga en cada entorno para validar el rendimiento de PrestaShop.
  2. Verifica el funcionamiento de WAF en cada entorno y revisa logs para posibles amenazas detectadas.
  3. Documenta las pruebas y optimizaciones realizadas en cada entorno en el archivo README.md.

Etapa 1: Configuración del Entorno ​

La primera etapa abarca la configuración del entorno en AWS y tu máquina local para facilitar el despliegue de PrestaShop. Aquí se detalla la instalación de herramientas, configuración del AWS CLI, creación de roles de IAM para permisos y documentación inicial.

1. Instalación de Herramientas Necesarias ​

Necesitaremos instalar varias herramientas para trabajar en AWS y con Kubernetes:

  1. AWS CLI:

    • Descarga e instala el AWS CLI aquí.
    • Verifica la instalación ejecutando:
      bash
      aws --version

  2. kubectl (para gestionar Kubernetes):

    • Descarga kubectl usando el siguiente comando:
      bash
      curl -o kubectl https://s3.us-west-2.amazonaws.com/amazon-eks/1.21.4/2021-09-27/bin/linux/amd64/kubectl
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin
    • Verifica la instalación con:
      bash
      kubectl version --client

  3. eksctl (para la gestión de EKS):

    • Descarga eksctl para crear y administrar clústeres de EKS:
      bash
      curl -sL https://github.com/weaveworks/eksctl/releases/download/0.73.0/eksctl_$(uname -s)_amd64.tar.gz | tar xz -C /tmp
sudo mv /tmp/eksctl /usr/local/bin
    • Verifica la instalación con:
      bash
      eksctl version

2. Configuración de AWS CLI ​

  1. Configura tu cuenta de AWS ejecutando:

    bash
    aws configure

    Aquí deberás ingresar:

    • Access Key ID y Secret Access Key de AWS.
    • Región en la que se desplegará la infraestructura (por ejemplo, us-west-2).
    • Formato de salida (recomendado json).

  2. Verifica que la CLI de AWS esté correctamente configurada probando un comando como:

    bash
    aws sts get-caller-identity

3. Creación de Roles de IAM ​

Para que los servicios como EKS y EFS puedan interactuar de manera segura, configuraremos roles de IAM con permisos específicos. Utilizaremos los archivos eks-role.yaml y efs-role.yaml dentro de la carpeta cloudformation/roles/ para definir estos permisos.

  1. Rol de IAM para EKS:

    • El archivo eks-role.yaml debería incluir políticas como AmazonEKSClusterPolicy, AmazonEKSWorkerNodePolicy, y AmazonEC2ContainerRegistryReadOnly. Este rol será asignado al clúster EKS.
    • Ejecuta el siguiente comando para crear el rol desde el archivo eks-role.yaml:
      bash
      aws cloudformation create-stack --stack-name eks-role --template-body file://cloudformation/roles/eks-role.yaml --capabilities CAPABILITY_NAMED_IAM
    • Verifica la creación del rol:
      bash
      aws cloudformation describe-stacks --stack-name eks-role

  2. Rol de IAM para EFS:

    • El archivo efs-role.yaml debe incluir políticas como AmazonElasticFileSystemClientReadWriteAccess, que permite a los pods en EKS acceder a los puntos de montaje de EFS.
    • Ejecuta el siguiente comando para crear el rol desde el archivo efs-role.yaml:
      bash
      aws cloudformation create-stack --stack-name efs-role --template-body file://cloudformation/roles/efs-role.yaml --capabilities CAPABILITY_NAMED_IAM
    • Verifica la creación del rol con:
      bash
      aws cloudformation describe-stacks --stack-name efs-role

4. Documentación Inicial en README.md ​

En esta etapa, es útil documentar la configuración y las herramientas en el archivo README.md del proyecto para un fácil seguimiento y reproducción de los pasos:

  1. Detalles de Instalación:

    • Incluye pasos detallados para la instalación de AWS CLI, kubectl y eksctl.
    • Agrega comandos de verificación para confirmar que las herramientas estén instaladas correctamente.

  2. Configuración de AWS CLI:

    • Documenta los pasos para configurar la CLI de AWS.
    • Explica cómo verificar la identidad de la cuenta con aws sts get-caller-identity.

  3. Configuración de Roles de IAM:

    • Incluye el propósito de cada rol de IAM y un enlace a los archivos de eks-role.yaml y efs-role.yaml.
    • Agrega comandos de creación de stacks con CloudFormation y la verificación de los roles.

Ejemplo de formato en README.md:

markdown
# PrestaShop en AWS con EKS, EFS, Aurora y WAF

## Etapa 1: Configuración del Entorno

### Instalación de Herramientas

1. **AWS CLI**: [Instrucciones de instalación](https://aws.amazon.com/cli/)
   ```bash
   aws --version

  1. kubectl

    bash
    curl -o kubectl https://s3.us-west-2.amazonaws.com/amazon-eks/1.21.4/2021-09-27/bin/linux/amd64/kubectl
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin

  2. eksctl

    bash
    curl -sL https://github.com/weaveworks/eksctl/releases/download/0.73.0/eksctl_$(uname -s)_amd64.tar.gz | tar xz -C /tmp
sudo mv /tmp/eksctl /usr/local/bin

Configuración de AWS CLI ​

bash
aws configure

Creación de Roles de IAM ​

  1. Rol para EKS:

    bash
    aws cloudformation create-stack --stack-name eks-role --template-body file://cloudformation/roles/eks-role.yaml --capabilities CAPABILITY_NAMED_IAM

  2. Rol para EFS:

    bash
    aws cloudformation create-stack --stack-name efs-role --template-body file://cloudformation/roles/efs-role.yaml --capabilities CAPABILITY_NAMED_IAM

Con esta configuración básica lista, estarás preparado para continuar con la siguiente etapa, la configuración de los clústeres EKS para los entornos DEV, STG y PROD. ¿Te gustaría avanzar a la siguiente etapa o necesitas más detalles sobre alguno de estos pasos?

Continuemos con la Etapa 2: Configuración de Clústeres EKS para Múltiples Entornos. En esta etapa, configuraremos tres clústeres separados de EKS para los entornos de DEV, STG y PROD, asegurando que cada entorno tenga su propio clúster de Kubernetes, lo cual facilita el aislamiento de recursos y el control de acceso.

Etapa 2: Configuración de Clústeres EKS para Múltiples Entornos ​

1. Despliegue de Clústeres de EKS ​

Para crear los clústeres de DEV, STG y PROD, puedes usar eksctl o un archivo de configuración de CloudFormation (eks-cluster.yaml). A continuación, detallo ambos enfoques.

Opción 1: Despliegue con eksctl ​

Utilizaremos eksctl para crear clústeres independientes, asegurándonos de configurar nombres únicos para cada clúster y opciones de recursos adecuadas.

  1. Clúster de DEV:

    bash
    eksctl create cluster --name dev-cluster --version 1.21 --region us-west-2 --nodegroup-name dev-nodes --nodes 2 --nodes-min 2 --nodes-max 4 --managed

  2. Clúster de STG:

    bash
    eksctl create cluster --name stg-cluster --version 1.21 --region us-west-2 --nodegroup-name stg-nodes --nodes 3 --nodes-min 3 --nodes-max 5 --managed

  3. Clúster de PROD:

    bash
    eksctl create cluster --name prod-cluster --version 1.21 --region us-west-2 --nodegroup-name prod-nodes --nodes 4 --nodes-min 4 --nodes-max 8 --managed

Los comandos anteriores crean cada clúster en la región us-west-2, pero puedes especificar una región diferente si es necesario. Además, cada clúster puede tener configuraciones distintas de tamaño de nodo y capacidad para ajustarse a las necesidades de cada entorno.

Opción 2: Despliegue con CloudFormation ​

Si prefieres utilizar CloudFormation para una administración más detallada o para registrar la infraestructura como código, puedes crear archivos de plantilla (eks-cluster.yaml) específicos para cada entorno. Este enfoque es útil cuando deseas reutilizar la configuración de los clústeres en el futuro o administrarlos desde la consola de AWS.

Ejemplo de comando para lanzar un clúster usando un archivo CloudFormation:

bash
aws cloudformation create-stack --stack-name dev-cluster --template-body file://cloudformation/eks-cluster.yaml --parameters ParameterKey=ClusterName,ParameterValue=dev-cluster ParameterKey=NodeGroupName,ParameterValue=dev-nodes ParameterKey=NodeCount,ParameterValue=2 --capabilities CAPABILITY_NAMED_IAM

Para crear los clústeres de STG y PROD, puedes modificar los parámetros ClusterName, NodeGroupName y NodeCount en el comando anterior o en el archivo eks-cluster.yaml.

2. Configuración de Contextos de kubectl para Cada Entorno ​

Una vez creados los clústeres, kubectl debe configurarse para que puedas alternar entre los diferentes contextos (es decir, DEV, STG y PROD) al interactuar con los clústeres.

  1. Obtén los detalles de configuración del clúster y agrégalos a kubectl:

    bash
    aws eks --region us-west-2 update-kubeconfig --name dev-cluster
aws eks --region us-west-2 update-kubeconfig --name stg-cluster
aws eks --region us-west-2 update-kubeconfig --name prod-cluster

  2. Verifica los contextos configurados:

    bash
    kubectl config get-contexts

  3. Cambia de contexto según el entorno en el que deseas trabajar:

    bash
    kubectl config use-context arn:aws:eks:us-west-2:<account_id>:cluster/dev-cluster

Al cambiar entre contextos, asegúrate de estar en el entorno correcto para evitar modificar recursos de producción accidentalmente.

3. Verificación del Estado de los Clústeres ​

Después de crear cada clúster, verifica que los nodos y recursos estén en funcionamiento correctamente:

  1. Lista los nodos en el clúster de DEV (o STG/PROD según el contexto actual):

    bash
    kubectl get nodes

  2. Verifica la salud de los servicios de Kubernetes ejecutando:

    bash
    kubectl get all --namespace kube-system

Si observas algún error en los nodos o pods del sistema, revisa los permisos de IAM y las configuraciones de red en la consola de AWS.

4. Documentación en README.md ​

En esta fase, actualiza el archivo README.md con detalles sobre la creación y configuración de los clústeres, incluyendo:

  • Comandos utilizados para crear cada clúster con eksctl o CloudFormation.
  • Configuración de contextos de kubectl para alternar entre DEV, STG y PROD.
  • Comandos de verificación para comprobar la salud y disponibilidad de cada clúster.

Ejemplo de formato de documentación en README.md:

markdown
## Etapa 2: Configuración de Clústeres EKS para Múltiples Entornos

### Creación de Clústeres

1. **DEV**:
   ```bash
   eksctl create cluster --name dev-cluster --version 1.21 --region us-west-2 --nodegroup-name dev-nodes --nodes 2 --nodes-min 2 --nodes-max 4 --managed

  1. STG:

    bash
    eksctl create cluster --name stg-cluster --version 1.21 --region us-west-2 --nodegroup-name stg-nodes --nodes 3 --nodes-min 3 --nodes-max 5 --managed

  2. PROD:

    bash
    eksctl create cluster --name prod-cluster --version 1.21 --region us-west-2 --nodegroup-name prod-nodes --nodes 4 --nodes-min 4 --nodes-max 8 --managed

Configuración de Contextos de kubectl ​

  1. Actualizar configuración para DEV:

    bash
    aws eks --region us-west-2 update-kubeconfig --name dev-cluster

  2. Verificación de contextos y cambio de contexto:

    bash
    kubectl config get-contexts
kubectl config use-context arn:aws:eks:us-west-2:<account_id>:cluster/dev-cluster

Verificación de Nodos y Estado del Clúster ​

Para DEV (repetir para STG y PROD):

bash
kubectl get nodes
kubectl get all --namespace kube-system

Con los clústeres DEV, STG y PROD configurados, el entorno de Kubernetes estará listo para el despliegue de componentes específicos en las siguientes etapas. ¿Te gustaría continuar con la Etapa 3: Implementación de EFS para Almacenamiento Compartido?

Etapa 3: Implementación de EFS para Almacenamiento Compartido ​

1. Creación de EFS en AWS ​

Para cada entorno (DEV, STG y PROD), deberás crear un sistema de archivos EFS que servirá como almacenamiento compartido para los clústeres de Kubernetes.

Creación de EFS con CloudFormation ​

  1. Utiliza el archivo de plantilla efs.yaml en la carpeta cloudformation/ para crear el sistema de archivos EFS. Cada sistema debe estar en la misma VPC que su respectivo clúster de EKS.

  2. Personaliza el archivo efs.yaml para cada entorno, especificando nombres únicos para cada EFS, como efs-dev, efs-stg, y efs-prod.

Ejemplo de comando para crear EFS para el entorno DEV:

bash
aws cloudformation create-stack --stack-name efs-dev --template-body file://cloudformation/efs.yaml --parameters ParameterKey=Environment,ParameterValue=dev

Repite el comando para STG y PROD, cambiando los valores de Environment y stack-name.

Creación Manual en la Consola (Alternativa) ​
  1. Ve a la consola de EFS en AWS y selecciona Create file system.
  2. Configura el sistema de archivos en la misma VPC que el clúster de EKS correspondiente.
  3. Configura Access Points para cada sistema de archivos, lo cual facilita la configuración de permisos y rutas de acceso a los pods en Kubernetes.
  4. Configura un Security Group que permita la comunicación desde los nodos del clúster de EKS.

2. Configuración de Access Points en EFS ​

Para facilitar el acceso a EFS desde Kubernetes, cada sistema de archivos EFS debe contar con un Access Point que sirva como un punto de acceso para los pods.

  1. En la consola de EFS, selecciona cada sistema de archivos creado y haz clic en Access Points.
  2. Crea un nuevo Access Point para cada entorno, como ap-dev, ap-stg, y ap-prod.
  3. Establece permisos de lectura/escritura y define un directorio raíz único para cada punto de acceso, asegurando así un aislamiento de datos entre entornos.

3. Creación de StorageClass para EFS en Kubernetes ​

Una vez que el sistema de archivos EFS esté configurado, define un StorageClass en cada clúster de Kubernetes para gestionar el almacenamiento persistente.

  1. Crea un archivo YAML para el StorageClass, por ejemplo, efs-sc.yaml, en cada entorno:

    yaml
    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: efs-sc
provisioner: efs.csi.aws.com
parameters:
  fileSystemId: <EFS_FILE_SYSTEM_ID> # Reemplaza con el ID del sistema EFS
  directoryPerms: "700"

  2. Reemplaza <EFS_FILE_SYSTEM_ID> con el ID del sistema de archivos EFS correspondiente para cada entorno.

  3. Aplica el StorageClass en cada clúster:

    bash
    kubectl apply -f k8s/dev/efs-sc.yaml

  4. Verifica que el StorageClass esté disponible en el clúster:

    bash
    kubectl get storageclass

4. Creación de PersistentVolume y PersistentVolumeClaim ​

Ahora, en cada clúster, crea un PersistentVolume (PV) y un PersistentVolumeClaim (PVC) que permitirán que los pods de PrestaShop accedan al sistema de archivos EFS.

  1. Crea un archivo YAML, como efs-pv.yaml, para el PersistentVolume en cada entorno:

    yaml
    apiVersion: v1
kind: PersistentVolume
metadata:
  name: efs-pv
spec:
  capacity:
    storage: 5Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  storageClassName: efs-sc
  csi:
    driver: efs.csi.aws.com
    volumeHandle: <EFS_FILE_SYSTEM_ID> # Reemplaza con el ID del sistema EFS

  2. Crea el PersistentVolumeClaim en el archivo efs-pvc.yaml:

    yaml
    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: efs-pvc
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: efs-sc
  resources:
    requests:
      storage: 5Gi

  3. Aplica ambos archivos YAML en el clúster:

    bash
    kubectl apply -f k8s/dev/efs-pv.yaml
kubectl apply -f k8s/dev/efs-pvc.yaml

  4. Verifica que el PVC esté vinculado al PV correctamente:

    bash
    kubectl get pvc
kubectl get pv

5. Documentación en README.md ​

En esta fase, documenta en el archivo README.md los pasos necesarios para configurar EFS en cada entorno. Incluye:

  • Creación de EFS con los comandos y parámetros utilizados para DEV, STG y PROD.
  • Configuración de Access Points para cada sistema de archivos EFS.
  • Creación de StorageClass, PersistentVolume y PersistentVolumeClaim.
  • Comandos de verificación y cualquier mensaje de error común.

Ejemplo de formato en README.md:

markdown
## Etapa 3: Implementación de EFS para Almacenamiento Compartido

### Creación de Sistemas de Archivos EFS

1. **DEV**:
   ```bash
   aws cloudformation create-stack --stack-name efs-dev --template-body file://cloudformation/efs.yaml --parameters ParameterKey=Environment,ParameterValue=dev

  1. STG:

    bash
    aws cloudformation create-stack --stack-name efs-stg --template-body file://cloudformation/efs.yaml --parameters ParameterKey=Environment,ParameterValue=stg

  2. PROD:

    bash
    aws cloudformation create-stack --stack-name efs-prod --template-body file://cloudformation/efs.yaml --parameters ParameterKey=Environment,ParameterValue=prod

Configuración de Access Points y Security Groups ​

Configura un Access Point único para cada sistema de archivos EFS y asegúrate de que los grupos de seguridad permiten el acceso desde los clústeres EKS correspondientes.

Creación de StorageClass, PV y PVC ​

  1. Crea y aplica un StorageClass en cada clúster para usar EFS:

    yaml
    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: efs-sc
provisioner: efs.csi.aws.com
parameters:
  fileSystemId: <EFS_FILE_SYSTEM_ID>
  directoryPerms: "700"

  2. Crea el PersistentVolume y el PersistentVolumeClaim para conectar PrestaShop a EFS.

Con esta configuración de EFS en cada entorno, los pods de PrestaShop tendrán acceso a almacenamiento persistente y compartido. Esto garantiza que los archivos, imágenes y otros datos de PrestaShop estén disponibles y sean consistentes en cada entorno.

Etapa 4: Configuración de Aurora MySQL ​

1. Creación de Clústeres de Aurora MySQL ​

Para cada entorno, debes crear un clúster de Aurora MySQL. Esto se puede hacer usando CloudFormation con el archivo aurora-mysql.yaml, o directamente en la consola de AWS.

Creación de Aurora MySQL con CloudFormation ​

  1. Utiliza el archivo de plantilla aurora-mysql.yaml en la carpeta cloudformation/ para crear un clúster de base de datos para cada entorno. Este archivo debe incluir parámetros como:

    • DBClusterIdentifier para identificar el clúster (por ejemplo, aurora-mysql-dev).
    • MasterUsername y MasterUserPassword para las credenciales de la base de datos.
    • DBSubnetGroupName para definir las subredes donde se alojará el clúster.

  2. Personaliza el archivo aurora-mysql.yaml para cada entorno y luego ejecuta el siguiente comando:

    bash
    aws cloudformation create-stack --stack-name aurora-mysql-dev --template-body file://cloudformation/aurora-mysql.yaml --parameters ParameterKey=Environment,ParameterValue=dev ParameterKey=DBClusterIdentifier,ParameterValue=aurora-mysql-dev --capabilities CAPABILITY_NAMED_IAM

  3. Repite el proceso para los entornos STG y PROD, reemplazando el valor de DBClusterIdentifier y el stack-name.

Configuración Manual en la Consola de AWS (Alternativa) ​
  1. En la consola de RDS, selecciona Create database y elige Amazon Aurora como tipo de base de datos.
  2. Selecciona MySQL como motor y configura el modo de aprovisionamiento de base de datos para cada entorno (DEV, STG, PROD).
  3. Configura el DB Cluster Identifier y define el nombre de usuario y contraseña del administrador.
  4. En la sección de Connectivity, asegúrate de seleccionar las subredes de la VPC correspondiente y los Security Groups que permitan el acceso desde el clúster EKS.

2. Configuración de Credenciales de Base de Datos en Kubernetes ​

Para que PrestaShop pueda acceder a Aurora MySQL, es necesario almacenar las credenciales de conexión en Kubernetes mediante Secrets.

  1. Crea un secreto en cada entorno (db-credentials.yaml) con las credenciales y la información de conexión:

    yaml
    apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: <BASE64_ENCODED_USERNAME>  # Codificado en base64
  password: <BASE64_ENCODED_PASSWORD>  # Codificado en base64
  endpoint: <BASE64_ENCODED_DB_ENDPOINT>  # Endpoint de Aurora, en base64
    • Usa el comando echo -n 'username' | base64 para convertir el valor a base64.
    • El valor de endpoint es el endpoint del clúster de Aurora MySQL para el entorno correspondiente.

  2. Aplica el secreto en cada clúster de Kubernetes:

    bash
    kubectl apply -f k8s/dev/db-credentials.yaml

  3. Verifica que el secreto se haya creado correctamente:

    bash
    kubectl get secret db-credentials

3. Pruebas de Conectividad a Aurora MySQL desde EKS ​

Para confirmar que el clúster de EKS puede conectarse al clúster de Aurora MySQL, crea un pod temporal en cada entorno que pruebe la conexión a la base de datos.

  1. Crea un archivo mysql-client.yaml para un pod que incluya el cliente MySQL:

    yaml
    apiVersion: v1
kind: Pod
metadata:
  name: mysql-client
spec:
  containers:
  - name: mysql-client
    image: mysql:5.7
    command: ["sleep", "3600"]

  2. Aplica el pod de prueba en el entorno:

    bash
    kubectl apply -f k8s/dev/mysql-client.yaml

  3. Conéctate al pod y prueba la conexión con Aurora MySQL usando los detalles de conexión almacenados en db-credentials:

    bash
    kubectl exec -it mysql-client -- mysql -h <AuroraEndpoint> -u <DB_USERNAME> -p<DB_PASSWORD>
    • Reemplaza <AuroraEndpoint>, <DB_USERNAME> y <DB_PASSWORD> con los valores adecuados.

  4. Una vez verificada la conexión, elimina el pod de prueba:

    bash
    kubectl delete pod mysql-client

4. Documentación en README.md ​

Documenta en README.md el proceso de configuración de Aurora MySQL, incluyendo:

  • Comandos de creación para cada entorno (DEV, STG, PROD) con CloudFormation.
  • Configuración de credenciales de la base de datos en Kubernetes mediante Secrets.
  • Pruebas de conectividad a Aurora desde EKS usando pods temporales.
  • Comandos de verificación y consejos para solucionar problemas comunes de conectividad.

Ejemplo de documentación en README.md:

markdown
## Etapa 4: Configuración de Aurora MySQL

### Creación de Clústeres de Aurora MySQL

1. **DEV**:
   ```bash
   aws cloudformation create-stack --stack-name aurora-mysql-dev --template-body file://cloudformation/aurora-mysql.yaml --parameters ParameterKey=Environment,ParameterValue=dev ParameterKey=DBClusterIdentifier,ParameterValue=aurora-mysql-dev --capabilities CAPABILITY_NAMED_IAM

  1. STG:

    bash
    aws cloudformation create-stack --stack-name aurora-mysql-stg --template-body file://cloudformation/aurora-mysql.yaml --parameters ParameterKey=Environment,ParameterValue=stg ParameterKey=DBClusterIdentifier,ParameterValue=aurora-mysql-stg --capabilities CAPABILITY_NAMED_IAM

  2. PROD:

    bash
    aws cloudformation create-stack --stack-name aurora-mysql-prod --template-body file://cloudformation/aurora-mysql.yaml --parameters ParameterKey=Environment,ParameterValue=prod ParameterKey=DBClusterIdentifier,ParameterValue=aurora-mysql-prod --capabilities CAPABILITY_NAMED_IAM

Configuración de Credenciales en Kubernetes ​

Crea un secreto en cada entorno (db-credentials.yaml) para almacenar las credenciales de conexión a la base de datos. Recuerda codificar en base64 el nombre de usuario, la contraseña y el endpoint de Aurora MySQL.

Pruebas de Conectividad a Aurora desde EKS ​

  1. Aplica el pod de prueba mysql-client.yaml en cada entorno para probar la conectividad.
  2. Usa el cliente MySQL en el pod para verificar la conexión con Aurora.
  3. Elimina el pod de prueba al finalizar la verificación.

Con Aurora MySQL configurado y conectado, PrestaShop tendrá acceso a una base de datos escalable y de alta disponibilidad en cada entorno. Esto asegura que los datos de la tienda estén centralizados y accesibles desde los diferentes pods de PrestaShop en Kubernetes.

Ahora pasaremos a la Etapa 5: Configuración de Memcached, en la cual configuraremos Memcached como un servicio de caché para PrestaShop en cada uno de los entornos DEV, STG y PROD. Memcached permitirá que PrestaShop almacene en caché consultas y sesiones de usuario, mejorando el rendimiento y la velocidad de carga de la aplicación.

Etapa 5: Configuración de Memcached ​

1. Creación de Instancias de Memcached ​

Cada entorno (DEV, STG y PROD) debe tener su propia instancia de Memcached para manejar la caché de manera aislada.

Creación de Memcached con CloudFormation ​

  1. Usa el archivo de plantilla memcached.yaml en la carpeta cloudformation/ para configurar una instancia de Memcached en cada entorno.

    • Configura un nombre único para cada stack y para cada instancia, por ejemplo, memcached-dev, memcached-stg y memcached-prod.
    • Establece los parámetros como la capacidad (por ejemplo, 1 GB para DEV y STG, 3 GB para PROD).

  2. Ejecuta el siguiente comando para crear la instancia de Memcached para DEV:

    bash
    aws cloudformation create-stack --stack-name memcached-dev --template-body file://cloudformation/memcached.yaml --parameters ParameterKey=Environment,ParameterValue=dev ParameterKey=NodeType,ParameterValue=cache.t2.micro

  3. Repite el comando para los entornos STG y PROD, ajustando los parámetros Environment y NodeType según las necesidades de cada entorno.

Configuración Manual en la Consola de AWS (Alternativa) ​
  1. Ve a la consola de ElastiCache en AWS y selecciona Create.
  2. Elige Memcached como motor de caché.
  3. Configura el Cluster Name y elige un Node Type adecuado (por ejemplo, cache.t2.micro para DEV y STG, cache.r5.large para PROD).
  4. Configura los Security Groups para permitir que los nodos del clúster EKS se conecten a la instancia de Memcached.

2. Configuración de Servicio Interno en Kubernetes para Conectar con Memcached ​

Para que los pods de PrestaShop puedan conectarse a Memcached en cada entorno, configura un Service interno en Kubernetes que dirija el tráfico al clúster de Memcached.

  1. Crea un archivo YAML de servicio, por ejemplo, memcached-svc.yaml, en la carpeta de cada entorno:

    yaml
    apiVersion: v1
kind: Service
metadata:
  name: memcached
  namespace: default
spec:
  type: ClusterIP
  ports:
    - port: 11211
      targetPort: 11211
  selector:
    app: memcached

  2. Aplica este archivo en cada clúster EKS, asegurándote de que el nombre del servicio sea el mismo en DEV, STG y PROD para una configuración consistente:

    bash
    kubectl apply -f k8s/dev/memcached-svc.yaml

  3. Verifica que el servicio esté creado correctamente:

    bash
    kubectl get svc memcached

3. Configuración de PrestaShop para Utilizar Memcached ​

Para conectar PrestaShop con Memcached, actualiza el archivo de configuración de PrestaShop (prestashop-configmap.yaml) para que cada entorno acceda a su instancia correspondiente.

  1. Crea o actualiza el archivo prestashop-configmap.yaml en cada entorno para que apunte al servicio de Memcached:

    yaml
    apiVersion: v1
kind: ConfigMap
metadata:
  name: prestashop-config
data:
  MEMCACHED_HOST: "memcached.default.svc.cluster.local"
  MEMCACHED_PORT: "11211"

  2. Aplica el ConfigMap en cada clúster EKS:

    bash
    kubectl apply -f k8s/dev/prestashop-configmap.yaml

  3. Verifica que el ConfigMap esté configurado correctamente:

    bash
    kubectl get configmap prestashop-config -o yaml

4. Pruebas de Conectividad a Memcached desde EKS ​

Para verificar la conexión a Memcached desde los pods en Kubernetes, puedes crear un pod de prueba con la herramienta telnet o nc.

  1. Crea un archivo memcached-client.yaml para un pod que incluya un cliente de red para probar la conexión:

    yaml
    apiVersion: v1
kind: Pod
metadata:
  name: memcached-client
spec:
  containers:
  - name: memcached-client
    image: busybox
    command: ["sleep", "3600"]

  2. Aplica el pod de prueba en el entorno deseado:

    bash
    kubectl apply -f k8s/dev/memcached-client.yaml

  3. Conéctate al pod y prueba la conexión a Memcached usando telnet o nc:

    bash
    kubectl exec -it memcached-client -- telnet memcached 11211

  4. Una vez verificada la conexión, elimina el pod de prueba:

    bash
    kubectl delete pod memcached-client

5. Documentación en README.md ​

Documenta en README.md el proceso de configuración de Memcached, incluyendo:

  • Comandos de creación de Memcached para cada entorno con CloudFormation.
  • Configuración del servicio interno en Kubernetes que permite a los pods conectarse a Memcached.
  • Configuración de PrestaShop para utilizar Memcached mediante ConfigMaps.
  • Pruebas de conectividad a Memcached desde un pod en Kubernetes y los comandos necesarios.

Ejemplo de documentación en README.md:

markdown
## Etapa 5: Configuración de Memcached

### Creación de Instancias de Memcached

1. **DEV**:
   ```bash
   aws cloudformation create-stack --stack-name memcached-dev --template-body file://cloudformation/memcached.yaml --parameters ParameterKey=Environment,ParameterValue=dev ParameterKey=NodeType,ParameterValue=cache.t2.micro

  1. STG:

    bash
    aws cloudformation create-stack --stack-name memcached-stg --template-body file://cloudformation/memcached.yaml --parameters ParameterKey=Environment,ParameterValue=stg ParameterKey=NodeType,ParameterValue=cache.t2.micro

  2. PROD:

    bash
    aws cloudformation create-stack --stack-name memcached-prod --template-body file://cloudformation/memcached.yaml --parameters ParameterKey=Environment,ParameterValue=prod ParameterKey=NodeType,ParameterValue=cache.r5.large

Configuración de Servicio Interno en Kubernetes ​

Crea y aplica un servicio interno para cada entorno en Kubernetes que apunte a Memcached:

yaml
apiVersion: v1
kind: Service
metadata:
  name: memcached
spec:
  type: ClusterIP
  ports:
    - port: 11211
      targetPort: 11211

Configuración de PrestaShop para Utilizar Memcached ​

Crea un ConfigMap para cada entorno con las variables MEMCACHED_HOST y MEMCACHED_PORT para que PrestaShop se conecte a Memcached:

yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: prestashop-config
data:
  MEMCACHED_HOST: "memcached.default.svc.cluster.local"
  MEMCACHED_PORT: "11211"

Pruebas de Conectividad a Memcached desde EKS ​

  1. Crea y aplica un pod de prueba memcached-client.yaml.
  2. Verifica la conexión con telnet memcached 11211.
  3. Elimina el pod de prueba después de la verificación.

Con Memcached configurado y en funcionamiento en cada entorno, PrestaShop puede aprovechar la caché para mejorar el rendimiento en la carga de páginas y la gestión de sesiones de usuario.

A continuación, desarrollaremos la Etapa 6: Configuración y Protección con AWS WAF para proteger las instancias de PrestaShop de posibles amenazas, como ataques de SQL Injection, Cross-Site Scripting (XSS) y fuerza bruta. AWS WAF permitirá establecer reglas de control de acceso y limitar las solicitudes maliciosas a través del balanceador de carga de cada entorno (DEV, STG y PROD).

Etapa 6: Configuración y Protección con AWS WAF ​

1. Creación de AWS WAF Web ACL (Access Control List) ​

Primero, debes crear una Web ACL en AWS WAF, donde configurarás reglas específicas para controlar y filtrar el tráfico hacia el balanceador de carga de cada entorno.

Creación de Web ACL con CloudFormation ​

  1. Usa el archivo de plantilla waf.yaml en la carpeta cloudformation/ para crear la Web ACL. Personaliza la configuración para incluir reglas de seguridad específicas, como protección contra SQL Injection y XSS, así como la limitación de solicitudes.

  2. Cada Web ACL debe tener un nombre único para cada entorno, por ejemplo, waf-dev, waf-stg y waf-prod.

  3. Ejecuta el siguiente comando para crear la Web ACL para el entorno DEV:

    bash
    aws cloudformation create-stack --stack-name waf-dev --template-body file://cloudformation/waf.yaml --parameters ParameterKey=Environment,ParameterValue=dev

  4. Repite el proceso para los entornos STG y PROD, cambiando los valores de Environment y stack-name.

Configuración Manual en la Consola de AWS (Alternativa) ​
  1. Ve a la consola de WAF & Shield en AWS y selecciona Create web ACL.
  2. Configura el Name y selecciona Region.
  3. En Associations, selecciona el balanceador de carga del entorno correspondiente (por ejemplo, el balanceador de carga de DEV).
  4. Agrega reglas de seguridad como AWS Managed Rules para proteger contra ataques comunes:
    • AWSManagedRulesCommonRuleSet: reglas básicas de protección.
    • AWSManagedRulesSQLiRuleSet: para prevenir SQL Injection.
    • AWSManagedRulesKnownBadInputsRuleSet: para bloquear entradas maliciosas.
    • AWSManagedRulesAnonymousIpList: para bloquear tráfico de IPs anónimas.

2. Configuración de Reglas Específicas en WAF ​

Para maximizar la seguridad en cada entorno, configura reglas específicas en la Web ACL de WAF:

  1. Reglas de Rate Limiting:

    • Configura reglas para limitar la cantidad de solicitudes por dirección IP en un período determinado. Esto ayuda a mitigar ataques de fuerza bruta.
    • En la configuración de reglas de WAF, agrega una regla de Rate Limiting (por ejemplo, 1000 solicitudes por minuto).

  2. Reglas contra XSS y SQL Injection:

    • Agrega las reglas AWSManagedRulesSQLiRuleSet y AWSManagedRulesXSSRuleSet para bloquear solicitudes que contengan patrones comunes de SQL Injection y XSS.

  3. Reglas de IP Blocklist:

    • Si tienes direcciones IP específicas conocidas como maliciosas, agrega reglas para bloquear estas IPs directamente.
    • Utiliza AWSManagedRulesAnonymousIpList para bloquear IPs de proxies conocidos o redes anónimas.

3. Asociación de WAF con el Load Balancer de Cada Entorno ​

Para que el WAF filtre el tráfico antes de que llegue a PrestaShop, asocia la Web ACL al balanceador de carga de cada entorno.

  1. En la consola de WAF, selecciona la Web ACL que creaste para el entorno (por ejemplo, waf-dev).
  2. En la sección de Associations, selecciona el balanceador de carga de la aplicación en DEV y haz clic en Associate.
  3. Repite estos pasos para los entornos STG y PROD, asegurándote de seleccionar los balanceadores de carga específicos de cada entorno.

4. Pruebas de Protección y Monitoreo en AWS WAF ​

Una vez configurado el WAF y asociado con el balanceador de carga, es importante realizar pruebas y monitorear la actividad para verificar que las reglas estén funcionando correctamente.

  1. Prueba de Acceso:

    • Accede a la aplicación desde una IP confiable y verifica que las páginas se carguen sin problemas.
    • Prueba los límites de rate limiting haciendo varias solicitudes rápidas y observa cómo se bloquean después del umbral configurado.

  2. Simulación de Ataques SQL y XSS:

    • Usa herramientas de prueba (como OWASP ZAP o scripts manuales) para enviar solicitudes que contengan patrones de SQL Injection o XSS. Asegúrate de que estas solicitudes sean bloqueadas por WAF.
    • Monitorea los registros de WAF para verificar que las solicitudes sean detectadas y bloqueadas.

  3. Monitoreo en la Consola de WAF:

    • En la consola de WAF, ve a Logging and metrics para ver el tráfico y las reglas activas.
    • Revisa los logs de WAF para ver estadísticas de las solicitudes bloqueadas, el origen de las IPs y cualquier anomalía detectada.

5. Documentación en README.md ​

Documenta en README.md el proceso de configuración de AWS WAF, incluyendo:

  • Creación de Web ACL en cada entorno (DEV, STG, PROD) y configuración de reglas de seguridad.
  • Asociación del WAF con el balanceador de carga de cada entorno.
  • Pruebas de protección y monitoreo para verificar que el WAF esté funcionando como se espera.
  • Comandos de verificación y solución de problemas comunes en caso de bloqueos o falsos positivos.

Ejemplo de documentación en README.md:

markdown
## Etapa 6: Configuración y Protección con AWS WAF

### Creación de Web ACL en AWS WAF

1. **DEV**:
   ```bash
   aws cloudformation create-stack --stack-name waf-dev --template-body file://cloudformation/waf.yaml --parameters ParameterKey=Environment,ParameterValue=dev

  1. STG:

    bash
    aws cloudformation create-stack --stack-name waf-stg --template-body file://cloudformation/waf.yaml --parameters ParameterKey=Environment,ParameterValue=stg

  2. PROD:

    bash
    aws cloudformation create-stack --stack-name waf-prod --template-body file://cloudformation/waf.yaml --parameters ParameterKey=Environment,ParameterValue=prod

Configuración de Reglas en WAF ​

  1. Rate Limiting: Limita las solicitudes a 1000 por minuto por IP.
  2. Protección contra XSS y SQL Injection: Agrega reglas administradas AWSManagedRulesSQLiRuleSet y AWSManagedRulesXSSRuleSet.
  3. IP Blocklist: Agrega AWSManagedRulesAnonymousIpList para bloquear IPs de proxies anónimos.

Asociación del WAF con el Balanceador de Carga ​

  1. En la consola de WAF, selecciona la Web ACL y asóciala con el balanceador de carga correspondiente para cada entorno (DEV, STG, PROD).

Pruebas de Protección y Monitoreo ​

  1. Accede a la aplicación desde IPs confiables y verifica que funcione sin problemas.
  2. Simula ataques de SQL Injection y XSS para probar que las reglas de WAF bloqueen las solicitudes.
  3. Monitorea los logs en Logging and metrics para revisar el tráfico y las solicitudes bloqueadas.

Con AWS WAF configurado y en funcionamiento, los entornos de PrestaShop estarán protegidos de amenazas comunes, y las reglas configuradas ayudarán a mantener un acceso seguro y eficiente.

Ahora abordaremos la Etapa 7: Despliegue de PrestaShop en Kubernetes, donde configuraremos y desplegaremos PrestaShop en cada clúster de Kubernetes en los entornos DEV, STG y PROD. Cada despliegue estará configurado para utilizar EFS como almacenamiento persistente, Aurora MySQL como base de datos y Memcached como sistema de caché.

Etapa 7: Despliegue de PrestaShop en Kubernetes ​

1. Creación de Archivos de Despliegue para PrestaShop ​

Crea un archivo YAML de despliegue para PrestaShop (prestashop-deployment.yaml) en cada entorno, asegurándote de que esté configurado para conectarse a los servicios de EFS, Aurora y Memcached.

Ejemplo de prestashop-deployment.yaml:

yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prestashop
  labels:
    app: prestashop
spec:
  replicas: 2
  selector:
    matchLabels:
      app: prestashop
  template:
    metadata:
      labels:
        app: prestashop
    spec:
      containers:
      - name: prestashop
        image: prestashop/prestashop:latest
        ports:
        - containerPort: 80
        env:
        - name: DB_SERVER
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: endpoint
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: username
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: password
        - name: MEMCACHED_HOST
          valueFrom:
            configMapKeyRef:
              name: prestashop-config
              key: MEMCACHED_HOST
        - name: MEMCACHED_PORT
          valueFrom:
            configMapKeyRef:
              name: prestashop-config
              key: MEMCACHED_PORT
        volumeMounts:
        - name: efs-volume
          mountPath: /var/www/html
      volumes:
      - name: efs-volume
        persistentVolumeClaim:
          claimName: efs-pvc

Este archivo define un despliegue para PrestaShop, donde:

  • EFS se utiliza para el almacenamiento persistente en la ruta /var/www/html.
  • Aurora MySQL se configura mediante variables de entorno para la conexión a la base de datos.
  • Memcached se utiliza como caché y está configurado con las variables MEMCACHED_HOST y MEMCACHED_PORT.

2. Aplicación del Despliegue en Kubernetes ​

Aplica el archivo prestashop-deployment.yaml en cada clúster (DEV, STG y PROD) para desplegar PrestaShop.

  1. Aplica el despliegue en el entorno DEV:

    bash
    kubectl apply -f k8s/dev/prestashop-deployment.yaml

  2. Repite el proceso para los entornos STG y PROD, asegurándote de usar los archivos de despliegue específicos de cada entorno.

  3. Verifica que el despliegue se haya creado y que los pods estén en ejecución:

    bash
    kubectl get pods -l app=prestashop

3. Creación de Servicio de Balanceador de Carga para Exponer PrestaShop ​

Para que PrestaShop esté accesible desde Internet, necesitas un servicio de LoadBalancer en cada entorno. Este servicio expondrá PrestaShop públicamente y permitirá que los usuarios accedan a la tienda en línea.

  1. Crea un archivo prestashop-svc.yaml para definir el servicio de PrestaShop:

    yaml
    apiVersion: v1
kind: Service
metadata:
  name: prestashop
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 80
  selector:
    app: prestashop

  2. Aplica el servicio en cada entorno:

    bash
    kubectl apply -f k8s/dev/prestashop-svc.yaml

  3. Verifica que el servicio de LoadBalancer esté creado y obtén la dirección IP externa (puede tardar unos minutos en estar disponible):

    bash
    kubectl get svc prestashop

    La columna EXTERNAL-IP mostrará la IP pública o el DNS del balanceador de carga, que puedes usar para acceder a PrestaShop en cada entorno.

4. Verificación del Despliegue ​

Una vez que los pods y el servicio de LoadBalancer estén en funcionamiento, accede a PrestaShop desde un navegador web usando la URL proporcionada por el balanceador de carga en cada entorno.

  1. Accede a la URL de PrestaShop en el entorno DEV, STG y PROD, y asegúrate de que la aplicación se carga correctamente.

  2. Realiza pruebas básicas, como:

    • Navegar por las secciones de la tienda.
    • Agregar productos al carrito.
    • Confirmar que las configuraciones de caché y base de datos están funcionando correctamente.

  3. Verifica los logs en Kubernetes para monitorear el estado de los pods de PrestaShop y verificar que no haya errores:

    bash
    kubectl logs -l app=prestashop

5. Documentación en README.md ​

Documenta en README.md el proceso de despliegue de PrestaShop en Kubernetes, incluyendo:

  • Archivos de despliegue de Kubernetes para configurar PrestaShop en cada entorno.
  • Configuración del servicio LoadBalancer para exponer la aplicación públicamente.
  • Comandos de verificación para confirmar que los pods y servicios están funcionando correctamente.
  • Pruebas básicas de funcionalidad para asegurarte de que PrestaShop esté operativo en cada entorno.

Ejemplo de documentación en README.md:

markdown
## Etapa 7: Despliegue de PrestaShop en Kubernetes

### Despliegue de PrestaShop en Kubernetes

1. **Aplicación de Despliegue**:
   ```bash
   kubectl apply -f k8s/dev/prestashop-deployment.yaml
   kubectl apply -f k8s/stg/prestashop-deployment.yaml
   kubectl apply -f k8s/prod/prestashop-deployment.yaml

  1. Configuración de Servicio LoadBalancer:

    bash
    kubectl apply -f k8s/dev/prestashop-svc.yaml
kubectl apply -f k8s/stg/prestashop-svc.yaml
kubectl apply -f k8s/prod/prestashop-svc.yaml

  2. Verificación de Despliegue y Servicio:

    • Listar los pods de PrestaShop:
      bash
      kubectl get pods -l app=prestashop
    • Obtener la IP externa del balanceador de carga:
      bash
      kubectl get svc prestashop

Pruebas de Acceso y Funcionalidad ​

  1. Accede a la URL pública proporcionada por el balanceador de carga en cada entorno.
  2. Realiza pruebas básicas de navegación, carrito de compras y carga de página para validar la aplicación.
  3. Revisa los logs de Kubernetes para verificar que no haya errores:
    bash
    kubectl logs -l app=prestashop

Con el despliegue de PrestaShop en Kubernetes completado y funcionando en cada entorno, ahora tu tienda en línea está operativa y configurada para alta disponibilidad, almacenamiento persistente y caché optimizada.

Ahora abordaremos la Etapa 7: Despliegue de PrestaShop en Kubernetes, donde configuraremos y desplegaremos PrestaShop en cada clúster de Kubernetes en los entornos DEV, STG y PROD. Cada despliegue estará configurado para utilizar EFS como almacenamiento persistente, Aurora MySQL como base de datos y Memcached como sistema de caché.

Etapa 7: Despliegue de PrestaShop en Kubernetes ​

1. Creación de Archivos de Despliegue para PrestaShop ​

Crea un archivo YAML de despliegue para PrestaShop (prestashop-deployment.yaml) en cada entorno, asegurándote de que esté configurado para conectarse a los servicios de EFS, Aurora y Memcached.

Ejemplo de prestashop-deployment.yaml:

yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prestashop
  labels:
    app: prestashop
spec:
  replicas: 2
  selector:
    matchLabels:
      app: prestashop
  template:
    metadata:
      labels:
        app: prestashop
    spec:
      containers:
      - name: prestashop
        image: prestashop/prestashop:latest
        ports:
        - containerPort: 80
        env:
        - name: DB_SERVER
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: endpoint
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: username
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: password
        - name: MEMCACHED_HOST
          valueFrom:
            configMapKeyRef:
              name: prestashop-config
              key: MEMCACHED_HOST
        - name: MEMCACHED_PORT
          valueFrom:
            configMapKeyRef:
              name: prestashop-config
              key: MEMCACHED_PORT
        volumeMounts:
        - name: efs-volume
          mountPath: /var/www/html
      volumes:
      - name: efs-volume
        persistentVolumeClaim:
          claimName: efs-pvc

Este archivo define un despliegue para PrestaShop, donde:

  • EFS se utiliza para el almacenamiento persistente en la ruta /var/www/html.
  • Aurora MySQL se configura mediante variables de entorno para la conexión a la base de datos.
  • Memcached se utiliza como caché y está configurado con las variables MEMCACHED_HOST y MEMCACHED_PORT.

2. Aplicación del Despliegue en Kubernetes ​

Aplica el archivo prestashop-deployment.yaml en cada clúster (DEV, STG y PROD) para desplegar PrestaShop.

  1. Aplica el despliegue en el entorno DEV:

    bash
    kubectl apply -f k8s/dev/prestashop-deployment.yaml

  2. Repite el proceso para los entornos STG y PROD, asegurándote de usar los archivos de despliegue específicos de cada entorno.

  3. Verifica que el despliegue se haya creado y que los pods estén en ejecución:

    bash
    kubectl get pods -l app=prestashop

3. Creación de Servicio de Balanceador de Carga para Exponer PrestaShop ​

Para que PrestaShop esté accesible desde Internet, necesitas un servicio de LoadBalancer en cada entorno. Este servicio expondrá PrestaShop públicamente y permitirá que los usuarios accedan a la tienda en línea.

  1. Crea un archivo prestashop-svc.yaml para definir el servicio de PrestaShop:

    yaml
    apiVersion: v1
kind: Service
metadata:
  name: prestashop
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 80
  selector:
    app: prestashop

  2. Aplica el servicio en cada entorno:

    bash
    kubectl apply -f k8s/dev/prestashop-svc.yaml

  3. Verifica que el servicio de LoadBalancer esté creado y obtén la dirección IP externa (puede tardar unos minutos en estar disponible):

    bash
    kubectl get svc prestashop

    La columna EXTERNAL-IP mostrará la IP pública o el DNS del balanceador de carga, que puedes usar para acceder a PrestaShop en cada entorno.

4. Verificación del Despliegue ​

Una vez que los pods y el servicio de LoadBalancer estén en funcionamiento, accede a PrestaShop desde un navegador web usando la URL proporcionada por el balanceador de carga en cada entorno.

  1. Accede a la URL de PrestaShop en el entorno DEV, STG y PROD, y asegúrate de que la aplicación se carga correctamente.

  2. Realiza pruebas básicas, como:

    • Navegar por las secciones de la tienda.
    • Agregar productos al carrito.
    • Confirmar que las configuraciones de caché y base de datos están funcionando correctamente.

  3. Verifica los logs en Kubernetes para monitorear el estado de los pods de PrestaShop y verificar que no haya errores:

    bash
    kubectl logs -l app=prestashop

5. Documentación en README.md ​

Documenta en README.md el proceso de despliegue de PrestaShop en Kubernetes, incluyendo:

  • Archivos de despliegue de Kubernetes para configurar PrestaShop en cada entorno.
  • Configuración del servicio LoadBalancer para exponer la aplicación públicamente.
  • Comandos de verificación para confirmar que los pods y servicios están funcionando correctamente.
  • Pruebas básicas de funcionalidad para asegurarte de que PrestaShop esté operativo en cada entorno.

Ejemplo de documentación en README.md:

markdown
### Etapa 7: Despliegue de PrestaShop en Kubernetes

### Despliegue de PrestaShop en Kubernetes

1. **Aplicación de Despliegue**:
   ```bash
   kubectl apply -f k8s/dev/prestashop-deployment.yaml
   kubectl apply -f k8s/stg/prestashop-deployment.yaml
   kubectl apply -f k8s/prod/prestashop-deployment.yaml

  1. Configuración de Servicio LoadBalancer:

    bash
    kubectl apply -f k8s/dev/prestashop-svc.yaml
kubectl apply -f k8s/stg/prestashop-svc.yaml
kubectl apply -f k8s/prod/prestashop-svc.yaml

  2. Verificación de Despliegue y Servicio:

    • Listar los pods de PrestaShop:
      bash
      kubectl get pods -l app=prestashop
    • Obtener la IP externa del balanceador de carga:
      bash
      kubectl get svc prestashop

Pruebas de Acceso y Funcionalidad ​

  1. Accede a la URL pública proporcionada por el balanceador de carga en cada entorno.
  2. Realiza pruebas básicas de navegación, carrito de compras y carga de página para validar la aplicación.
  3. Revisa los logs de Kubernetes para verificar que no haya errores:
    bash
    kubectl logs -l app=prestashop

Con el despliegue de PrestaShop en Kubernetes completado y funcionando en cada entorno, ahora tu tienda en línea está operativa y configurada para alta disponibilidad, almacenamiento persistente y caché optimizada.

En esta última etapa, cubriremos la Etapa 8: Configuración de Servicios y Exposición en la que afinaremos la configuración de servicios, aseguraremos la exposición pública adecuada y optimizaremos el acceso a PrestaShop en los entornos DEV, STG y PROD. Esto implica revisar las configuraciones de seguridad, asegurarnos de que los balanceadores de carga funcionan correctamente, y realizar pruebas finales.

Etapa 8: Configuración de Servicios y Exposición ​

1. Revisión de la Configuración del Balanceador de Carga ​

Cada despliegue de PrestaShop está expuesto al público a través de un servicio de tipo LoadBalancer en Kubernetes, asociado a un balanceador de carga en AWS. Es esencial revisar que cada balanceador esté configurado correctamente y funcione según las necesidades de cada entorno.

  1. Verifica la Configuración de Seguridad:

    • Asegúrate de que cada balanceador de carga esté asociado a Security Groups que permitan el tráfico HTTP/HTTPS en los puertos 80 y 443.
    • En AWS, revisa que los Security Groups estén configurados para permitir el tráfico únicamente desde direcciones IP de confianza si es necesario, especialmente en STG y PROD.

  2. Configuración de HTTPS:

    • Para los entornos de producción, es recomendable habilitar HTTPS mediante la instalación de un certificado SSL en el balanceador de carga. Esto puede hacerse a través de AWS Certificate Manager (ACM).
    • En la consola de AWS, solicita un certificado para el dominio de producción y asócielo al balanceador de carga.
    • Configura redireccionamiento HTTP a HTTPS para forzar el uso seguro en producción.

2. Revisión de la Asociación con WAF ​

Cada balanceador de carga debería estar asociado con una Web ACL de AWS WAF para proteger PrestaShop contra ataques comunes.

  1. En la consola de AWS WAF, verifica que la Web ACL esté asociada correctamente con el balanceador de carga de cada entorno.
  2. Asegúrate de que las reglas de rate limiting, XSS, y SQL Injection estén habilitadas y activas.
  3. Revisa los logs de WAF para monitorear tráfico y ataques bloqueados, ajustando las reglas según las necesidades de cada entorno.

3. Pruebas Finales de Conectividad y Funcionamiento ​

Realiza pruebas de conectividad y funcionamiento en cada entorno para asegurar que PrestaShop está funcionando correctamente y es accesible a través del balanceador de carga.

  1. Pruebas de Acceso:

    • Accede a PrestaShop desde un navegador web utilizando la URL del balanceador de carga de cada entorno (DEV, STG, PROD).
    • Para cada entorno, verifica la carga de página, tiempos de respuesta y acceso a todas las secciones de la tienda.

  2. Pruebas de HTTPS en Producción:

    • Para el entorno de producción, confirma que la URL utiliza HTTPS.
    • Realiza pruebas de redireccionamiento HTTP a HTTPS para asegurar que la aplicación está forzando el uso de HTTPS correctamente.

  3. Pruebas de Seguridad con WAF:

    • Simula intentos de ataques básicos (por ejemplo, patrones de SQL Injection y XSS) y verifica en los logs de WAF que estas solicitudes sean bloqueadas.
    • Asegúrate de que las reglas de rate limiting están en funcionamiento haciendo múltiples solicitudes rápidas desde una misma IP y confirmando que el acceso es restringido.

  4. Revisión de Logs en Kubernetes:

    • Revisa los logs de los pods de PrestaShop para monitorear errores y advertencias. Esto puede hacerse con el siguiente comando:
      bash
      kubectl logs -l app=prestashop

4. Documentación en README.md ​

Documenta en README.md los detalles de configuración de servicios y exposición de PrestaShop, incluyendo:

  • Configuración de Balanceador de Carga y HTTPS para cada entorno.
  • Asociación y verificación de WAF en los balanceadores de carga.
  • Pruebas de acceso y funcionalidad para asegurar que PrestaShop esté operativo.
  • Pruebas de seguridad y conectividad para verificar que las reglas de WAF y HTTPS están funcionando correctamente.

Ejemplo de documentación en README.md:

markdown
## Etapa 8: Configuración de Servicios y Exposición

### Revisión de Configuración del Balanceador de Carga

1. Asegúrate de que los **Security Groups** permiten el tráfico HTTP/HTTPS en los puertos 80 y 443.
2. Habilita **HTTPS en producción** usando AWS Certificate Manager y configura el balanceador de carga para redireccionar tráfico HTTP a HTTPS.

### Asociación con AWS WAF

1. Confirma que cada balanceador de carga esté asociado con la **Web ACL** correspondiente.
2. Verifica que las reglas de protección (rate limiting, SQL Injection, XSS) están habilitadas y funcionando.

### Pruebas Finales de Conectividad y Funcionamiento

1. **Acceso a PrestaShop**: Verifica el acceso a la aplicación en cada entorno usando las URL proporcionadas por los balanceadores de carga.
2. **Pruebas HTTPS**: Asegúrate de que el entorno de producción está forzando el uso de HTTPS.
3. **Pruebas de Seguridad**: Simula ataques básicos y verifica que WAF bloquea las solicitudes maliciosas.
4. **Revisión de Logs**: Revisa los logs en Kubernetes para identificar errores o advertencias en los pods de PrestaShop.

Con la configuración de servicios y exposición en cada entorno completa, tu despliegue de PrestaShop está ahora seguro y accesible públicamente a través de balanceadores de carga protegidos por WAF y con HTTPS habilitado en producción. Este entorno multizona es ideal para escalar, monitorear y asegurar el acceso en un ambiente seguro de comercio electrónico en la nube.