¿Debería utilizar Kubernetes? La respuesta, en pocas palabras, depende. Pero déjame guiarte a través de mi viaje a la comprensión de Kubernetes, y tal vez podría ayudarte a encontrar tu propia respuesta.
Escribí un libro entero para ayudar a guiarlo en su camino a Kubernetes (obtener el MEAP de versión anticipada de Manning aquí). Pero antes de hablar sobre el libro, vamos a hablar un poco sobre el despliegue de software y mi viaje que conduce a ella.
Hace casi dos décadas, me embarqué en mi primer intento de desplegar software en Internet para publicar mi primer sitio web. Por aquel entonces, no tenía ni idea de por dónde empezar. Un par de amigos de la familia tuvieron la amabilidad de ofrecerme algunos consejos:
sugirió el empresario:
"Coge este libro sobre Dreamweaver y HTML y no necesitarás gastar ni un céntimo para desarrollar tu primer sitio web".
El administrador del sistema y el desarrollador adoptaron un enfoque diferente:
"Toma, déjame que te configure un servidor FTP para alojar tu web; no te recomiendo aprender a gestionar servidores".
Ambas personas me ayudaron a llegar a donde estoy hoy, pero una de ellas retrasó involuntariamente mi aprendizaje durante mucho tiempo. ¿Adivinas quién?
Al recordar mis primeros días, queda claro lo cruciales que fueron tanto los conocimientos básicos como el aprendizaje a través de la experiencia práctica para dar forma a mi trayectoria. Los consejos del emprendedor me empujaron a sumergirme de lleno en el desarrollo web, mientras que la orientación del administrador de sistemas me enseñó el valor de las herramientas que podían simplificar tareas complejas.
Sin embargo, una lección clave que surgió con el tiempo fue la importancia de comprender los principios fundamentales, incluso cuando se utilizan herramientas de alto nivel. Esta experiencia de aprendizaje temprana fue la génesis de mi interés por Kubernetes, una tecnología que tendría un impacto significativo en mi trayectoria profesional. Entender Kubernetes, como cualquier otra herramienta, requiere una comprensión firme de la tecnología subyacente.
¿Es complejo Kubernetes? Sí. ¿Es perfecto? No. ¿Es adecuado para todas las situaciones? Pero la cuestión de si debe o no utilizar Kubernetes a menudo se reduce a su comprensión de la tecnología subyacente que hace que Kubernetes sea tan potente y cómo puede utilizarla para gestionar y proteger su software.
Para aquellos que se pregunten: "¿Qué es Kubernetes?" o quizás aún no estén familiarizados con el término "Docker" (más allá del tipo de pantalones) y su asociación con los contenedores, permítanme que se lo explique.
Las aplicaciones evolucionan constantemente, y cada componente, desde la base de datos hasta el lenguaje de programación, publica nuevas versiones con frecuencia. Hacer un seguimiento de las múltiples versiones de cada aplicación y de las numerosas iteraciones de componentes de terceros puede convertirse en un suplicio, sobre todo cuando se trata de versiones antiguas o heredadas sin soporte general. Incluso las versiones de software compatibles tienen muchas dependencias de instalación a nivel de sistema y de terceros que pueden añadir complejidad a la ejecución del software, por no hablar de intentar utilizarlo como componente de su aplicación.
Con el tiempo, todo el software acaba quedando obsoleto y es sustituido por versiones más recientes. El reto consiste en utilizar software antiguo cuando sea necesario. Incluso cambios aparentemente pequeños en el software pueden tener un gran impacto en las aplicaciones modernas. Por ejemplo, Python 2.7 (comparado con el más reciente Python 3.11) solía estar integrado en el Mac OS X de Apple. Python 2.7 tenía una extraña sintaxis para la salida de texto a la línea de comandos: `print "this thing" ` en lugar de la versión más lógica de `print("this thing")` que se encuentra en las versiones más recientes de Python. Esta pieza de sintaxis puede romper toda una aplicación heredada Python debido a la falta de paréntesis.
Aunque utilizar versiones antiguas de software puede resultar poco práctico, no cabe duda de que hay situaciones en las que necesitamos ejecutar software antiguo. Pero, ¿cómo?
Podríamos dedicar tiempo a encontrar una pieza de hardware o una imagen de máquina virtual de un momento determinado que nos permitiera ejecutar un programa antiguo. O podemos recurrir a los contenedores, un concepto en el que Docker fue pionero. Los contenedores son aplicaciones autocontenidas empaquetadas con sus dependencias que podemos modificar a nuestro antojo. Su principal ventaja es su capacidad para pasar sin problemas de un sistema a otro.
He aquí un ejemplo de Dockerfile que utiliza Python 2.7 como bloque de construcción de un contenedor:
```dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
``````dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
```Este Dockerfile le dice a Docker lo que se necesita para construir este nuevo contenedor con código que existe en nuestra máquina local y ruta local bajo `/src`. Dockerfiles puede ser mucho más complicado, pero este ejemplo muestra lo fácil que puede ser el uso de Docker.
Para construir-ejecutar esta aplicación en contenedores, es tan simple como:
```bash
docker build -f Dockerfile -t hello-python:v1 .
docker run hello-python -p 8000:8000
```Sin la contenedorización, tendríamos que instalar Python 2.7 directamente en una máquina, lo que casi nunca es sencillo. Docker y otros contenedores pueden hacer que nuestras aplicaciones sean portátiles, y puedes sustituir Python 2.7 en este ejemplo por casi cualquier lenguaje o herramienta de código abierto.
Sin embargo, el problema surge cuando queremos actualizar una aplicación en contenedores, especialmente en producción. Localmente, actualizar un contenedor es sencillo. Dejas de ejecutar el contenedor, lo reconstruyes y lo vuelves a ejecutar. En producción, sin embargo, la actualización de un contenedor se puede hacer de la misma manera, pero corremos el riesgo de un tiempo de inactividad importante si la construcción falla.
Ahí es donde entra en juego Kubernetes. Kubernetes ayuda a gestionar el enrutamiento del tráfico a contenedores específicos y supervisa el número de contenedores que se ejecutan en un momento dado. Si un contenedor falla, Kubernetes facilita la reversión a versiones anteriores con un tiempo de inactividad mínimo o nulo.
La configuración para desplegar un contenedor en Kubernetes se denomina manifiesto. Este es un ejemplo de un manifiesto relativamente sencillo:
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-py-deploy
spec:
replicas: 3
selector:
matchLabels:
app: hello-py-deploy
template:
metadata:
labels:
app: hello-py-deploy
spec:
containers:
- name: hello-py-container
image: jmitchel3/hello-python:v1
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: hello-py-service
spec:
type: LoadBalancer
ports:
- name: http
port: 80
targetPort: 8080
protocol: TCP
selector:
app: hello-py-deploy
```En el ejemplo anterior, el manifiesto de Kubernetes con formato yaml proporciona dos recursos: un servicio de equilibrio de carga y un despliegue. El equilibrador de carga ayuda a dirigir el tráfico a nuestro despliegue. A través de `replicas: 3`, de nuestro contenedor declarado `hello-python:v1`, nuestro despliegue ejecuta 3 versiones.
Ahora, cuando queramos actualizar la versión desplegada, podemos cambiar `hello-python:v1` a `hello-python:v2` y Kubernetes actualizará nuestra aplicación. Y si algo va mal, volverá a `hello-py-deploy:v1`. Kubernetes hace que este proceso sea sencillo y fácil de gestionar. Los manifiestos pueden ser fácilmente controlados por versiones con git, por lo que podemos ser muy granulares con nuestras capacidades de reversión. Kubernetes forma parte integral de la implementación porque proporciona un marco para automatizar, escalar y gestionar aplicaciones en contenedores, garantizando la resistencia y la eficiencia del sistema en nuestros entornos de software cada vez más complejos.
Quería repasar algunos de los métodos que me llevaron a descubrir cómo Kubernetes podía simplificar el despliegue de mis aplicaciones. Sacar el máximo provecho de Kubernetes me llevó varios pasos, pero fue un viaje que valió la pena. En Road to Kubernetes, vamos a ir en un viaje para desplegar aplicaciones utilizando diversas tecnologías que son importantes para entender antes de saltar en Kubernetes y otras prácticas modernas de despliegue.
En Road to Kubernetes veremos cómo:
- Gestión de repositorios git en plataformas autoalojadas o en la nube
- Despliegue de aplicaciones Python y Node.js a través de máquinas virtuales basadas en la nube con git.
- Automatice la configuración e implantación de máquinas virtuales con Ansible
- Contenedorización y despliegue de aplicaciones con Docker y Docker Compose
- Ejecutar contenedores directamente en máquinas virtuales sin orquestación
- Empujar y alojar contenedores con el registro de DockerHub
- Despliegue de aplicaciones en contenedores en Kubernetes
- Implementación de aplicaciones públicas y privadas en Kubernetes
- Configuración de balanceadores de carga para tráfico HTTP y HTTPs
- Utilizar técnicas CI/CD con Github Actions y la alternativa de código abierto act by Nectos
- y mucho más.
El despliegue es la prueba definitiva de su software. Road to Kubernetes condensa quince años de experiencia en despliegue en una guía práctica y accesible. Te lleva desde el despliegue de software desde cero hasta la implementación de la potencia de Kubernetes. Aprenderá prácticas de despliegue sostenibles que puede utilizar con cualquier lenguaje y cualquier tipo de aplicación web, cómo crear aplicaciones portátiles que pueden moverse a través de opciones de despliegue y proveedores de nube, y verá lo posible que es utilizar Kubernetes para proyectos de cualquier tamaño.
Comentarios