|
|
| (No se muestran 18 ediciones intermedias del mismo usuario) |
| Línea 1: |
Línea 1: |
| Requisitos IP Variable por ISP:
| | == Servir un Sitio HTML5 Utilizando una Imagen Docker Liviana con Apache == |
|
| |
|
| Configurar un servicio **DDNS** en mi router Ej: **no-ip.com**, y además, crear un registro **CNAME** en el DNS de su dominio con el subdominio Ej: '''domus.maxiscomputers.com''' el cual apunte a su DDNS, en este caso Ej: '''maxiscomputers.dyndns.net'''.
| | Para servir el sitio HTML5 utilizando una imagen Docker liviana con Apache, utilizaremos una imagen basada en Alpine, que es una de las distribuciones de Linux más ligeras disponibles. Alpine es ideal para casos en los que se busca minimizar el tamaño de las imágenes y mejorar la eficiencia en Kubernetes. |
|
| |
|
| == Requerimientos == | | === Dockerfile === |
| | <pre># Usa la imagen de Apache en Alpine como base |
| | FROM httpd:alpine |
| | # Copia los archivos de tu sitio web a la carpeta de Apache |
| | COPY html/ /usr/local/apache2/htdocs/ |
| | # Expone el puerto 80 para servir el sitio |
| | EXPOSE 80 |
| | # Comando para iniciar Apache en modo foreground |
| | CMD ["httpd-foreground"]</pre> |
|
| |
|
| Quiero adaptar mi clúster de Kubernetes para que haga proxy inverso y genere automáticamente un certificado SSL con **Let's Encrypt**. ¿Es esto posible, dado esta arquitectura de DDNS y CNAME entre el dominio final que va a usar el usuario vs el DDNS?
| | === Estructura del Proyecto === |
| | El sitio web HTML5 se encuentra en una carpeta llamada ''html'' en el directorio anterior está el Dockerfile. Esta estructura es común en proyectos web estáticos. |
|
| |
|
| === Descripción del Escenario === | | === Pasos para construir y ejecutar la imagen === |
| * **DDNS con no-ip.com**: Utilizas un DDNS para gestionar los cambios de IP de tu router, con '''maxiscomputers.dyndns.net''' como dominio proporcionado.
| |
| * **Subdominio personalizado**: '''domus.maxiscomputers.com''' es el subdominio, con un registro CNAME apuntando a '''maxiscomputers.dyndns.net'''.
| |
| * **Let's Encrypt**: Usarás Let's Encrypt para generar certificados SSL para el subdominio '''domus.maxiscomputers.com'''.
| |
|
| |
|
| === Retos a Considerar === | | ==== Construir la imagen Docker: ==== |
| * **Verificación de Let's Encrypt (HTTP-01)**: Let's Encrypt necesita verificar el control sobre tu dominio antes de emitir un certificado. Para la verificación HTTP-01, se comprobará un archivo expuesto en la ruta '''http://domus.maxiscomputers.com/.well-known/acme-challenge/''' desde tu clúster.
| |
| * **Actualización de IP**: Como tu IP cambia cada 24 horas, debes asegurarte de que el DDNS esté actualizado para que Let's Encrypt apunte a la IP correcta al hacer la verificación. No-ip.com se encarga de este aspecto.
| |
| * **Certificado para CNAME**: A pesar de que el subdominio real apunta a un DDNS, Let's Encrypt validará el dominio '''domus.maxiscomputers.com''' para emitir el certificado.
| |
|
| |
|
| === Solución Propuesta ===
| | <pre>docker build -t maxiscomputers.com:latest .</pre> |
| Usaremos **cert-manager** en el clúster de Kubernetes, junto con un Ingress Controller (como **NGINX** o **Traefik**) para manejar el tráfico HTTPS y solicitar automáticamente los certificados de Let's Encrypt. El Ingress Controller actuará como un proxy inverso para redirigir el tráfico, y cert-manager gestionará los certificados SSL.
| |
|
| |
|
| ==== Pasos a Seguir ==== | | ==== Ejecutar la imagen en un contenedor: ==== |
|
| |
|
| 1. **Instalar cert-manager**
| | <pre>docker run -d -p 80:80 maxiscomputers.com:latest</pre> |
|
| |
|
| Cert-manager gestionará la obtención y renovación de los certificados SSL de Let's Encrypt automáticamente.
| | Con esto, estarías sirviendo tu sitio web estático a través del puerto 80. |
|
| |
|
| ```bash
| | === Ventajas de usar Alpine === |
| # Agrega el repositorio Helm de Jetstack
| | * '''Tamaño reducido''': Las imágenes basadas en Alpine suelen ser mucho más pequeñas que las tradicionales. |
| helm repo add jetstack https://charts.jetstack.io
| | * '''Eficiencia en Kubernetes''': Usar imágenes más livianas ayuda a mejorar los tiempos de despliegue y a reducir el consumo de recursos en un clúster. |
| | |
| # Instala cert-manager en tu clúster
| |
| helm install cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace --version v1.10.0
| |
| ```
| |
| | |
| 2. **Crear un ClusterIssuer para Let's Encrypt**
| |
| | |
| Configura un ClusterIssuer para que cert-manager pueda solicitar certificados de Let's Encrypt usando la verificación HTTP-01.
| |
| | |
| ```yaml
| |
| apiVersion: cert-manager.io/v1
| |
| kind: ClusterIssuer
| |
| metadata:
| |
| name: letsencrypt-prod
| |
| spec:
| |
| acme:
| |
| server: https://acme-v02.api.letsencrypt.org/directory
| |
| email: <tu-email> # Reemplaza con tu email
| |
| privateKeySecretRef:
| |
| name: letsencrypt-prod
| |
| solvers:
| |
| - http01:
| |
| ingress:
| |
| class: nginx
| |
| ```
| |
| | |
| Aplica el ClusterIssuer:
| |
| | |
| ```bash
| |
| kubectl apply -f clusterissuer.yaml
| |
| ```
| |
| | |
| 3. **Configurar el Ingress para tu Aplicación**
| |
| | |
| Suponiendo que tienes un servicio en el puerto 80 en Kubernetes, configuraremos un recurso Ingress para gestionar el proxy inverso y la solicitud del certificado SSL.
| |
| | |
| ```yaml
| |
| apiVersion: networking.k8s.io/v1
| |
| kind: Ingress
| |
| metadata:
| |
| name: domus-ingress
| |
| namespace: default
| |
| annotations:
| |
| cert-manager.io/cluster-issuer: "letsencrypt-prod"
| |
| nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
| |
| spec:
| |
| rules:
| |
| - host: domus.maxiscomputers.com # El dominio para el que solicitas el certificado
| |
| http:
| |
| paths:
| |
| - path: /
| |
| pathType: Prefix
| |
| backend:
| |
| service:
| |
| name: your-service-name # Cambia por el nombre de tu servicio
| |
| port:
| |
| number: 80
| |
| tls:
| |
| - hosts:
| |
| - domus.maxiscomputers.com
| |
| secretName: domus-tls # Nombre del secreto que contendrá el certificado SSL
| |
| ```
| |
| | |
| Aplica el Ingress:
| |
| | |
| ```bash
| |
| kubectl apply -f ingress.yaml
| |
| ```
| |
| | |
| 4. **Verificar la Configuración de DDNS**
| |
| | |
| Asegúrate de que el dominio '''domus.maxiscomputers.com''' esté correctamente apuntando a '''maxiscomputers.dyndns.net''', y que tu router actualice el DDNS automáticamente.
| |
| | |
| 5. **Configurar Ingress Controller (NGINX)**
| |
| | |
| Si aún no tienes un Ingress Controller, puedes instalar NGINX con:
| |
| | |
| ```bash
| |
| helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
| |
| helm install ingress-nginx ingress-nginx/ingress-nginx --namespace ingress-nginx --create-namespace
| |
| ```
| |
| | |
| === Renovación Automática del Certificado ===
| |
| Cert-manager se encargará de renovar el certificado antes de su vencimiento (por defecto, cuando falten 30 días).
| |
| | |
| == Conclusión ==
| |
| | |
| Con esta configuración, **cert-manager** solicitará automáticamente un certificado SSL para tu dominio '''domus.maxiscomputers.com''', a pesar de que uses un CNAME hacia un DDNS. El certificado se renovará automáticamente y el Ingress Controller (NGINX en este caso) gestionará el tráfico y la redirección a HTTPS.
| |
Servir un Sitio HTML5 Utilizando una Imagen Docker Liviana con Apache
Para servir el sitio HTML5 utilizando una imagen Docker liviana con Apache, utilizaremos una imagen basada en Alpine, que es una de las distribuciones de Linux más ligeras disponibles. Alpine es ideal para casos en los que se busca minimizar el tamaño de las imágenes y mejorar la eficiencia en Kubernetes.
Dockerfile
# Usa la imagen de Apache en Alpine como base
FROM httpd:alpine
# Copia los archivos de tu sitio web a la carpeta de Apache
COPY html/ /usr/local/apache2/htdocs/
# Expone el puerto 80 para servir el sitio
EXPOSE 80
# Comando para iniciar Apache en modo foreground
CMD ["httpd-foreground"]
Estructura del Proyecto
El sitio web HTML5 se encuentra en una carpeta llamada html en el directorio anterior está el Dockerfile. Esta estructura es común en proyectos web estáticos.
Pasos para construir y ejecutar la imagen
Construir la imagen Docker:
docker build -t maxiscomputers.com:latest .
Ejecutar la imagen en un contenedor:
docker run -d -p 80:80 maxiscomputers.com:latest
Con esto, estarías sirviendo tu sitio web estático a través del puerto 80.
Ventajas de usar Alpine
- Tamaño reducido: Las imágenes basadas en Alpine suelen ser mucho más pequeñas que las tradicionales.
- Eficiencia en Kubernetes: Usar imágenes más livianas ayuda a mejorar los tiempos de despliegue y a reducir el consumo de recursos en un clúster.
