Docker: la herramienta para empaquetar nuestras aplicaciones

 

Docker es la herramienta ideal que nos permite empaquetar nuestras aplicaciones. Gracias a la filosofía de los contenedores, los cuales son entornos aislados para nuestro código. Estos contienen todo lo necesario para que nuestro código (aplicaciones) e ejecuten en cualquier otro sistema. Olvidémonos de las máquinas virtuales, de los requerimientos engorrosos, de las instalaciones y dependencias. Con Docker se nos abre un mundo donde el desarrollar, enviar y ejecutar aplicaciones es algo sencillo.

Docker ofrece:

1. Portabilidad de nuestras aplicaciones.
2. Aislamiento, cada contenedor es independiente.
3. Consistencia, no hay errores.
4. Escalabilidad, podemos actualizar o extender nuestros desarrollos.
5. Construir e implementar más fácilmente.

En este blog ya hemos hablado sobre esta herramienta que se ha vuelto muy popular en los últimos años. Así como su relación con Kubernetes. Y es que ambas herramientas son indispensables en el mundo del Devops y Cloud.

En esta ocasión veremos cómo instalarlo en un entorno Windows.

Para descargarlo debemos ir al sitio oficial:

https://www.docker.com/

En la sección https://www.docker.com/products/docker-desktop/  descargaremos Docker Desktop. Esta es una aplicación que nos permitirá instalar Docker en nuestras máquinas. Para sistemas operativos Mac OS, Linux y Windows.

Nosotros usaremos un instalador de Windows.

Una vez teniendo el ejecutable y dando doble clic iniciará la instalación.

Le daremos OK.

Nota: En SO Windows debe estar habilitada la opción de virtualización. Puedes checar este vídeo: https://www.youtube.com/watch?v=Tl4kODRGtIc

Además tendrás que tener habilitada la característica de Microsoft Hyper-V.

Volviendo a la instalación.

Cuando finalice la instalación deberemos reiniciar.

Deberás tener una cuenta en https://hub.docker.com/ para poder iniciar o crear una nueva si es que no la tienes.

En caso de que salga un error de tipo WSL abre una terminal y escribe:

$ wsl --update

Esto instalará el subsistema de Windows para Linux y se reiniciará el Docker Engine.

¡Instalación finalizada!

Con esto tendremos Docker en nuestra máquina.

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/02/diferencias-entre-docker-y-kubernetes.html

https://es.wikipedia.org/wiki/Docker_(software)

https://hub.docker.com/

Alternativas a Kubernetes

Kubernetes es un sistema de orquestación de contenedores para su despliegue, escalado y gestión que se ha vuelto el más usado en el mundo de la informática y computación.

Ya sea porque tiene una gran comunidad, documentación a granel, y diversas herramientas que lo complementan. Sin embargo, no es el único sistema que existe para la administración de contenedores.

Alternativas a Kubernetes

He aquí una lista de algunas aternativas a Kubernetes.

Nombre	Descripción
Docker Swarm	Es una herramienta software, integrada en Docker, que permite ejecutar los contenedores en una granja de nodos. Basada en una arquitectura maestro-esclavo (manager-worker).
Hashicorp Nomad	Un orquestador simple y flexible para implementar y administrar contenedores y aplicaciones no contenerizadas en instalaciones locales y en la nube a escala.
Apache Mesos	Es un gestor de clústeres de código abierto que funciona como un sistema operativo distribuido para ejecutar aplicaciones a gran escala en un clúster de servidores.

Docker Swarm

El orquestador nativo de Docker que permite gestionar y coordinar múltiples contenedores en un clúster de máquinas. Sirve para:

• Escalar aplicaciones: Distribuye contenedores en nodos para balancear carga. 
• Alta disponibilidad: Replica servicios para garantizar continuidad si un nodo falla. 
• Gestión simplificada: Facilita el despliegue, actualización y monitoreo de aplicaciones contenerizadas. 
• Automatización: Administra recursos y tareas en un entorno distribuido.

Las diferencias con respecto a Kubernetes son:

• Complejidad: Docker Swarm es más simple, fácil de configurar y usar, ideal para proyectos pequeños. Kubernetes es más complejo, con mayor curva de aprendizaje, pero más robusto para entornos grandes. 
• Escalabilidad: Kubernetes soporta clústeres más grandes y complejos, con mejor manejo de recursos. Swarm es menos escalable, pero suficiente para aplicaciones medianas. 
• Funcionalidades: Kubernetes ofrece más características avanzadas (como autoescalado sofisticado, políticas de red complejas). Swarm tiene menos opciones, pero es más ligero. 
• Integración: Swarm está integrado nativamente con Docker. Kubernetes requiere herramientas adicionales, pero es más flexible con diferentes entornos.

Docker Swarm es más simple y rápido; Kubernetes es más potente y versátil.

Hashicorp Nomad

Es un orquestador ligero y flexible que gestiona y despliega aplicaciones (contenedores, aplicaciones tradicionales, tareas batch) en clústeres. Características:

• Orquestación: Automatiza el despliegue, escalado y gestión de aplicaciones. 
• Flexibilidad: Soporta contenedores (Docker, Podman) y aplicaciones no contenerizadas (binarios, Java, etc.). 
• Simplicidad: Facilita la gestión de clústeres con una configuración sencilla. 
• Tareas variadas: Ideal para cargas de trabajo batch, servicios continuos y entornos heterogéneos.

Diferencias con Kubernetes:

• Complejidad: Nomad es más simple, con menos sobrecarga y configuración más rápida. Kubernetes es más complejo, con una curva de aprendizaje mayor. 
• Escalabilidad: Kubernetes es más robusto para clústeres grandes y complejos. Nomad escala bien, pero es más ligero y adecuado para entornos medianos o heterogéneos. 
• Funcionalidades: Kubernetes ofrece más características avanzadas (autoescalado, políticas de red, CRDs). Nomad es más minimalista, pero versátil para cargas mixtas. 
• Ecosistema: Nomad se integra bien con herramientas HashiCorp (Consul, Vault); Kubernetes tiene un ecosistema más amplio y es el estándar para nubes. 
• Casos de uso: Nomad es ideal para simplicidad y cargas mixtas (contenedores y no contenedores). Kubernetes es mejor para microservicios complejos y entornos empresariales.

Nomad es más ligero y flexible para entornos variados; Kubernetes es más potente y completo, pero complejo.

Apache Mesos

Es es un orquestador de clústeres que gestiona recursos (CPU, memoria, almacenamiento) en un entorno distribuido. Características:

• Gestión de recursos: Asigna recursos dinámicamente a aplicaciones o frameworks. 
• Escalabilidad: Maneja clústeres masivos, ideal para big data y cargas mixtas. 
• Soporte multi-framework: Ejecuta contenedores (vía Marathon), Spark, Hadoop, etc. 
• Alta disponibilidad: Distribuye tareas para garantizar continuidad.

Diferencias respecto a Kubernetes:

• Complejidad: Mesos es más complejo, requiere frameworks adicionales (como Marathon para contenedores). Kubernetes es más integrado y específico para contenedores. 
• Enfoque: Mesos es genérico, diseñado para cargas mixtas (big data, contenedores, etc.). Kubernetes está optimizado para aplicaciones contenerizadas y microservicios. 
• Escalabilidad: Ambos son altamente escalables, pero Mesos es mejor para clústeres heterogéneos y grandes cargas de big data. Kubernetes brilla en entornos de contenedores modernos. 
• Funcionalidades: Kubernetes ofrece más herramientas nativas (autoescalado, redes, almacenamiento). Mesos depende de frameworks como Marathon para funcionalidades similares. 
• Ecosistema: Kubernetes tiene una comunidad más grande y un ecosistema robusto. Mesos tiene soporte decreciente y es más niche para big data.

Mesos es versátil para entornos mixtos y big data; Kubernetes es el estándar para contenedores y microservicios modernos.

Tabla resumen

Aspecto	Docker Swarm	Kubernetes	Hashicorp Nomad	Apache Mesos
Complejidad	Simple, fácil configuración, ideal para principiantes.	Complejo, mayor curva de aprendizaje, pero muy configurable.	Moderada, más simple que Kubernetes, flexible.	Complejo, requiere experiencia para gestionar clústeres grandes.
Escalabilidad	Escala bien para clústeres medianos, menos robusto en entornos masivos.	Altamente escalable, ideal para clústeres grandes y complejos.	Escala bien, soporta cargas mixtas (contenedores y no contenedores).	Muy escalable, diseñado para clústeres masivos y heterogéneos.
Funcionalidades	Básicas: balanceo de carga, alta disponibilidad, actualizaciones continuas.	Avanzadas: autoescalado, políticas de red, almacenamiento dinámico, CRDs.	Flexibles: soporta contenedores y aplicaciones tradicionales, tareas batch.	Amplias: soporta múltiples frameworks, ideal para big data y cargas mixtas.
Integración	Nativa con Docker, integración sencilla con herramientas Docker.	Ecosistema amplio, compatible con múltiples nubes y herramientas.	Integración con HashiCorp (Consul, Vault), menos dependiente de un ecosistema.	Compatible con múltiples frameworks (Marathon para contenedores, Spark, etc.).
Casos de uso	Proyectos pequeños a medianos, entornos con necesidades simples.	Aplicaciones empresariales, microservicios complejos, entornos multi-nube.	Entornos heterogéneos, tareas batch, simplicidad con escalabilidad.	Grandes clústeres, cargas de big data, entornos mixtos (contenedores y no contenedores).
Comunidad y soporte	Comunidad activa, pero menos soporte tras el auge de Kubernetes.	Gran comunidad, soporte empresarial robusto, estándar de facto.	Comunidad creciente, soporte sólido de HashiCorp.	Comunidad más enfocada en big data, soporte decreciente para Marathon.
Rendimiento	Ligero, menor consumo de recursos.	Mayor consumo de recursos, pero optimizado para cargas pesadas.	Ligero, eficiente para cargas mixtas.	Pesado, optimizado para clústeres grandes y heterogéneos.

En conclusión. Cada una de las alternativas tiene su propia filosofía de trabajo. Si no se quiere usar Kubernetes, se puede optar por alguna de estas alternativas presentadas.

Enlaces:

https://www.makingscience.es/blog/que-es-docker-swarm/
https://developer.hashicorp.com/nomad
https://mesos.apache.org/
https://beecrowd.com/es/blog-posts/apache-mesos-3/
https://medium.com/@williamwarley/harnessing-apache-mesos-and-marathon-a-practical-deployment-guide-on-vmware-and-aws-4919d95ffaf7

Helm, una herramienta para administrar paquetes Kubernetes

Helm es una herramienta software que nos ayuda a encontrar, compartir y usar software construido para Kubernetes.

Salvando las distancias es como un CPAN o cualquier otro gestor de paquetes.

Como hemos hablado en otros posts, Kubernetes es un gestor de contenedores que se encarga del mantenimiento, organización y la escalabilidad de nuestros contenedores (que pueden estar hechos o no con Docker). Helm vendría siendo su propio CPAN. Si se requiere un paquete para Kubernetes, esta herramienta la podrá buscar e instalar en nuestro ambiente. También podrá permitirnos agregar repositorios donde podremos descargar paquetes o compartir los nuestros.

Helm se une a las decenas (¿o centenas o quizás miles?) de herramientas DevOps que son populares hoy en día.

Esta herramienta requiere cierto conocimiento sobre herramientas como Docker y, por supuesto, Kubernetes.

La documentación oficial provee guías sobre su uso. Comandos de lo básico a lo avanzado y hasta ejemplos de cómo se debería usar.

Un concepto dentro de Helm son los Charts. Según la documentación oficial, los Charts de Helm te ayudan a definir, instalar y actualizar incluso la aplicación de Kubernetes más compleja. Originalmente, el objetivo de Helm era proporcionar a los usuarios una forma mejor de gestionar todos los archivos YAML de Kubernetes que creamos en los proyectos de Kubernetes.

¿Qué es un Chart Helm?

En pocas plabras, es un paquete que contiene toda la información necesaria para implementar una aplicación en Kubernetes.

Los Charts son fáciles de crear, versionar, compartir y publicar - así que puedes comienzar a utilizar Helm y deja de copiar y pegar.

Helm instala todo el árbol de dependencias de un proyecto si ejecuta el comando install para el gráfico de nivel superior. Sólo tiene que ejecutar un único comando para instalar toda su aplicación, en lugar de listar los ficheros a instalar mediante ``kubectl``.

Tampoco olvidar el ``config``, el cual contiene información de configuración que puede fusionarse en un chart empaquetado para crear un objeto releaseable. Y el ``release``, que es una instancia en ejecución de un chart, combinado con un config específico.

Estos son los tres conceptos que debemos tener presentes al usar Helm.

Instalando Helm

Requisitos:

• Un clúster de Kubernetes configurado y accesible. 
• Tener la herramienta ``kubectl` instalada y configurada para interactuar con el clúster. 
•  Un entorno local con acceso a la línea de comandos.

Para instalarlo, puedes ir a este sitio y descargarlo:

https://github.com/helm/helm/releases/tag/v3.18.5

También existe la opción de instalarlo mediante con un administrador de paquetes como Homebrew, chocolatey , scoop o snap:

Homebrew:

$ brew install helm

Chocolatey:

$ choco install kubernetes-helm

Scoop

$ scoop install helm

Snap:

$ sudo snap install helm --classic

Una vez instalado en tu equipo deberás agregarlo a tu PATH. Para validar la instalación, abre una consola y escribe:

$ helm version

Podemos agregar un repositorio:

$ helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

Buscar un paquete:

$ helm search repo ingress-nginx

Actualizar el repositorio:

$ helm repo update

Continuando con la documentación oficial de Helm, nos ayuda a:

• Nos permite crear nuevos charts (paquetes) desde cero. 
• Empaquetar charts en archivos de charts (tgz). 
• Interactuar con repositorios de charts donde se almacenan charts. 
• Instalar y desinstalar charts en un clúster Kubernetes existente. 
• Gestionar el ciclo de lanzamiento de los charts instalados con Helm.

En conclusión, Helm nos ayuda con la gestión de las aplicaciones de Kubernetes y es una herramienta que se ha vuelto esencial en gestiones de DevOps. Es necesario tener nociones semi avanzadas o avanzadas sobre Docker y Kubernetes si le queremos sacar un buen provecho a la herramienta.

Enlaces:

https://helm.sh
https://codemonkeyjunior.blogspot.com/2025/01/kubernetes-como-si-le-explicaras-tu.html
https://www.freecodecamp.org/espanol/news/que-es-un-helm-chart-un-tutorial-para-principiantes-en-kubernetes/
https://learn.microsoft.com/es-es/azure/aks/kubernetes-helm?WT.mc_id=containers-19838-ludossan

Kubernetes en un vistazo

Continuamos con esta serie de entregas sobre Docker y Kubernetes

Según la documentación oficial Kubernetes (k8s) es una plataforma de código abierto para automatizar la implementación, el escalado y la administración de aplicaciones en contenedores.

Básicamente es una plataforma de código abierto que orquesta contenedores (como los de Docker) en grupos distribuidos de servidores.

¿Para qué sirve?

• Escalar aplicaciones fácilmente (de 1 a 1,000 contenedores sin perder el control).
• Distribuir carga entre servidores. 
• Recuperarse automáticamente si algo falla.
• Declarar el estado ideal (Kubernetes se encarga de mantenerlo).

Es como tener un director de orquesta que sabe cuándo y dónde deben sonar los instrumentos (contenedores) para que la sinfonía (tu app) no se detenga.

Comandos básicos

Observemos ahora algunos de los comandos más usados en Kubernetes.

Crear un Deployment que maneje un Pod:

$ kubectl create deployment hello-node --image=registry.k8s.io/echoserver:1.4

Ver el Deployment:

$ kubectl get deployments

Mostrar los contenedores que están corriendo en un clúster:

$ kubectl get pods

Mostrar los eventos del clúster:

$ kubectl get events

Mostrar la configuración:

$ kubectl config view

Crear o actualizar recursos desde un archivo YAML:

$ kubectl apply -f application.yaml

Mostrar información detallada del Pod:

$ kubectl describe pod mypod

Mostrar los logs del contenedor:

$ kubectl logs mypod

Mostrar todos los recursos:

$ kubectl get all

Eliminar recursos definidos en el archivo YAML:

$ kubectl delete -f application.yaml

Interacción con Docker

En una entrega anterior vimos el flujo de trabajo con Docker.

Ahora imaginemos que tienes una aplicación en un contenedor Docker. Para que Kubernetes la administre, se crea un archivo de configuración (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mi-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mi-app
  template:
    metadata:
      labels:
        app: mi-app
    spec:
      containers:
      - name: mi-app
        image: usuario/mi-imagen:latest
        ports:
        - containerPort: 80

Ahora desplegamos con Kubernetes:

$ kubectl apply -f deployment.yaml

Se podría usar Docker Swarm en lugar de Kubernetes por simplicidad y rapidez. Sin embargo, si tu proyecto es algo más complejo es mejor usar Kubernetes. Ya que es ideal para arquitecturas complejas, microservicios y entornos empresariales.

Este solo es un pequeño vistazo a lo que es Kubernetes. Continuaremos con este tema en próximas entregas.

Enlaces:

https://kubernetes.io/
https://codemonkeyjunior.blogspot.com/2025/07/docker-conociendo-el-flujo-de-trabajo.html
https://codemonkeyjunior.blogspot.com/2025/01/docker-en-palabras-sencillas.html
https://alquimistadecodigo.blogspot.com/2020/07/docker-imagenes-y-contenedores.html
https://hub.docker.com/
https://alquimistadecodigo.blogspot.com/2020/03/docker-instalacion.html
https://alquimistadecodigo.blogspot.com/2020/08/docker-instalando-una-imagen-de-nimrod.html

Docker: conociendo el flujo de trabajo

 

En esta entrega veremos el flujo de trabajo en Docker.

Tomemos como referencia la siguiente imagen:

Todo inicia con nuestra aplicación (MyApp). Que es la que queremos subir a un contenedor Docker.

Para ello debemos crear un archivo llamado Dockerfile. El cual contendrá todas las dependencias, rutas y configuraciones necesarias para hacer funcionar nuestra aplicación.

Una vez teniendo este archivo, docker se encargará de crear la imagen, la cual es un paquete autocontenido con todo lo necesario para ejecutar la aplicación.

Posteriormente tendremos un contenedor, que es la instancia activa y aislada de la aplicación corriendo en el sistema.

Todo gracias al motor de Docker (Docker Engine), el componente que interpreta el Dockerfile, construye la imagen, lanza el contenedor y gestiona todo ese flujo. Es el corazón del ecosistema Docker.

El SO anfitrión donde reside Docker puede ser un SO Linux, Mac OS o Windows.

Básicamente este es flujo de trabajo de Docker. Omitiendo su interracción con Kubernetes.

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/01/docker-en-palabras-sencillas.html
https://alquimistadecodigo.blogspot.com/2020/07/docker-imagenes-y-contenedores.html
https://hub.docker.com/

Utiliza la IA DeepSeek en local con Ollama + Docker (Youtube)

Lamentablemente el canal ha sido borrado.

En este vídeo nos enseñan como ejecutar DeepSeek (esa I.A. que ha "desplazado" al otrora rey ChatGPT) de manera local.

Pero, antes que nada, deberías saber algunos conceptos.

¿Qué es Ollana y para qué sirve?

Ollama es una plataforma de código abierto diseñada para ejecutar modelos de lenguaje (LLMs) de manera local en tu ordenador.

Su principal función es permitir a los usuarios descargar, instalar y utilizar estos modelos de inteligencia artificial sin necesidad de depender de servicios en la nube.

Para empezar con Ollama, los usuarios deben descargarlo de su sitio web oficial, compatible actualmente con macOS y Linux, y seguir las instrucciones de instalación para su sistema operativo.

Una vez instalado, se pueden descargar y ejecutar diferentes modelos desde una biblioteca disponible, lo que permite una amplia gama de experimentos y aplicaciones en inteligencia artificial.

Ollama puede ser utilizado para tareas como:

• Automatización de tareas repetitivas. 
• Generación y análisis de texto. 
• Traducción automática. 
• Respuestas a consultas en sistemas de búsqueda.

Esperemos que te sirva este mini tutorial hecho por @josemarialabarta en su canal de Youtube.

Enlaces:

https://chat.deepseek.com/
https://ollama.com/
https://aws.amazon.com/es/what-is/large-language-model/

Diferencias entre Docker y Kubernetes

Debemos aclarar que:

Docker es una herramienta para crear y gestionar contenedores.

• Una plataforma de contenerización. 
• Empaqueta aplicaciones y dependencias en contenedores. 
• Garantiza la portabilidad entre entornos. 
• Ejecuta contenedores en un solo host. 
• Se utiliza en procesos de CI/CD para la automatización de la implementación.

Pero, ¿Qué diantres es un contenedor? Digamos, en términos simples y sencillos:

Es como una pequeña casa portátil para un programa. Tendrá todo lo necesario para ejecutar un programa en otra máquina. Sin tener que preocuparse por la configuración de la misma.

Si solo vas a usar contenedores, con Docker es más que suficiente.

Si requieres algo más como escalabilidad, tendrás que usar Kubernetes.

Docker vs Kubernetes: What’s the Difference?

Both are essential in modern cloud-native development and DevOps, but they serve different purposes. Understanding the difference is key for efficient container management in cloud computing and microservices architectures.

Docker… pic.twitter.com/z8q11e5sFF

— Nina (@HeyNina101) February 2, 2025

Kubernetes, por su parte, nos ayuda a gestionar contenedores en producción.

• Es un sistema de orquestación de contenedores. 
• Gestiona aplicaciones en contenedores a escala. 
• Maneja la implementación, el escalamiento y la red. 
• Distribuye cargas de trabajo entre múltiples nodos. 
• Optimizado para microservicios y aplicaciones nativas de la nube.

Con Docker podemos crear y ejecutar contenedores y con Kubernetes podremos organizar y administrar esos contenedores a escala. Ambos, Docker & Kubernetes, permiten flujos de trabajo escalables y resilientes de computación en la nube y DevOps.

Enlaces:

https://x.com/HeyNina101/status/1885951537525985333

Kubernetes como si le explicarás a tu mascota (o a un niño de cinco años)

Kubernetes explicado en términos sencillos:

"Supongamos que tienes muchos juguetes, como carritos, muñecas y bloques. Si los dejas todos tirados, sería un desastre, ¿verdad? Kubernetes es como un amigo mágico que ayuda a ordenar todos tus juguetes".

1. Organiza: Te ayuda a poner todos los juguetes en grupos. Por ejemplo, todos los carritos juntos, todas las muñecas en otro lugar. 
2. Mantiene el orden: Si un juguete se rompe o se pierde, Kubernetes puede sacar otro del mismo tipo para que sigas jugando sin problemas. 
3. Comparte: Si tienes amigos jugando contigo, Kubernetes asegura que todos tengan los juguetes que necesitan, sin que nadie se quede sin nada.

Así que, Kubernetes es como un super organizador que hace que jugar con muchos juguetes sea divertido y sin enredos

"Piensa en Kubernetes como un gerente muy eficiente de una gran empresa, pero en lugar de empleados, maneja aplicaciones y servicios en computadoras".

Imagina que tienes una tienda con muchas sucursales. Cada sucursal necesita tener ciertos productos (aplicaciones) en stock y funcionando bien:

1. Organización: Kubernetes se asegura de que cada sucursal tenga los productos correctos. Si una sucursal necesita más de un producto específico, Kubernetes lo distribuye automáticamente.
2. Mantenimiento: Si algún producto no funciona bien en una sucursal, Kubernetes lo reemplaza o repara sin que tú tengas que intervenir directamente. Así, tus clientes siempre tienen lo que necesitan sin interrupciones. 
3. Escalabilidad: Si de repente hay mucha demanda en una sucursal, Kubernetes puede aumentar rápidamente el número de productos disponibles sin que tengas que preocuparte por la logística.

En resumen, Kubernetes es un sistema que automatiza la gestión, distribución y mantenimiento de aplicaciones en múltiples computadoras, asegurándose de que todo funcione sin problemas, incluso cuando la demanda cambia.

Relación con Docker

Piensa en Docker y Kubernetes como dos partes de un equipo que trabajan juntas para hacer más fácil la gestión de aplicaciones.

"Docker es como una caja mágica para empacar tus cosas. Imagina que cada aplicación es un juguete y Docker te permite meter cada juguete en su propia caja especial (un contenedor). Esta caja asegura que el juguete funcione de la misma manera, sin importar en qué lugar lo saques. Así, puedes mover tus aplicaciones de una computadora a otra sin problemas".

"Kubernetes, por otro lado, es el gerente que organiza todas esas cajas (contenedores de Docker). Si tienes muchas cajas, Kubernetes se encarga de:

• Colocarlas en los estantes correctos (las computadoras adecuadas). 
• Mantenerlas en orden, asegurándose de que siempre haya cajas disponibles si una se rompe o si necesitas más. 
• Distribuir las cajas según la necesidad, si una área necesita más de cierto tipo de juguete, Kubernetes lo maneja.

En resumen, Docker es para empaquetar y asegurar que tus aplicaciones funcionen de manera consistente, mientras que Kubernetes es para gestionar y escalar esos paquetes de manera eficiente en múltiples computadoras.

Ambos trabajan juntos para que la tecnología detrás de las aplicaciones sea más manejable y menos complicada para ti.

Enlaces:

https://kubernetes.io/es/docs/concepts/overview/what-is-kubernetes/

Docker en palabras sencillas

En pasados post ya hemos hablado algo sobre Docker:

• https://codemonkeyjunior.blogspot.com/2020/09/docker-instalando-erlang.html
• https://codemonkeyjunior.blogspot.com/2020/09/docker-instalando-elixir.html

¿Qué es Docker?

Es como una caja que guarda tu aplicación con todo lo necesario para ejecutarse en cualquier otra máquina.

Es decir, es una caja donde se empaquetan las configuraciones, librerías, etc. de tu aplicación (Java, Go, Python, Node JS, etc.). Esta caja podrá ser "abierta" en otra máquina y podrá ejecutar tu aplicación sin tener que instalar y/o configurar absolutamente nada.

Similar a lo que hacíamos anteriormente en una Máquina Virtual. De hecho, Docker las ha venido reemplazando.

Mientras que una Máquina Virtual necesita su propio sistema operativo, tarda minutos en arrancar, consume muchos recursos de memoria RAM y espacio en el disco, Docker es más ligero, consume pocos recursos, arranca en segundos y usa el núcleo del sistema host.

Podríamos decir que: Docker es una especie de Máquina Virtual mejorada.

Preguntando a Grok, nos dice:

"Imagina que Docker es como una caja mágica. Dentro de esa caja, puedes poner todo lo que necesita un programa para funcionar, como sus juguetes y herramientas favoritas".

"Cuando cierras la caja, puedes llevarla a cualquier lugar, y al abrirla, el programa funcionará exactamente igual que en casa, sin importar dónde estés. Así que, con Docker, puedes mover programas de un lugar a otro sin que se rompan o se porten mal".

¿Qué es un contenedor?

Un contenedor en Docker es como una pequeña casa portátil para un programa.

"Imagina que tienes un juguete que necesita una casa especial para vivir. Esta casa tiene todo lo que necesita el juguete: su cama, su comida, y sus juegos".

"Cuando metes el juguete en su casa portátil, puedes llevarlo a cualquier parte, y siempre estará feliz porque tiene todo lo que necesita dentro de su casa. Así es un contenedor; es una casa pequeña y especial donde tu programa vive y puede funcionar en cualquier lugar al que lo lleves".

¿Dónde se guardan los contenedores?

Se almacenan repositorios, ya sean públicos y/o privados.

Un ejemplo es Docker Hub.

Los contenedores y las imágenes se almacenan dentro del sistema de archivos de la máquina virtual que Docker Desktop utiliza.

Se gestionan y organizan gracias al demonio (un programa que se ejecuta en segundo plano) de Docker.

Preguntando a Grok, nos dice:

"Los contenedores se guardan en un lugar especial en tu computadora, que podemos imaginar como un gran parque de juegos".

"Piensa en tu computadora como un parque enorme. En este parque, hay un área especial donde están todas las casitas de juguetes (los contenedores)". "Cuando no estás jugando con una casita, la dejas en este parque, donde está segura y lista para que la uses cuando quieras".

"Así que, los contenedores se guardan en una parte de tu computadora reservada solo para ellos, donde pueden esperar hasta que decidas usarlos de nuevo".

Un contenedor en Docker puede tener:

• Imagen.
• Volúmenes.
•  Redes.

¿Qué es una Imagen?

Una imagen en Docker es como un libro de instrucciones para construir una casa de juguetes.

"Imagina que quieres construir una casa para tu juguete. Antes de empezar, necesitas un libro que te diga exactamente cómo hacer la casa, con todos los detalles: qué materiales usar, cómo poner las paredes, el techo, y hasta dónde irán las ventanas".

Una imagen en Docker es exactamente eso, pero para programas. Es un libro de instrucciones que tiene todo lo necesario para crear una casa portátil (un contenedor) para tu programa. Cada vez que quieras hacer una nueva casa igual, solo sigues las instrucciones del libro, y ¡listo! Tienes una nueva casa para tu programa.

Una imagen, por lo tanto, tendrá el sistema operativo base, las dependencias y todo lo que tu aplicación necesita para trabajar.

Instalando Erlang con Docker

Instalamos una imagen de Erlang con Docker:

$ docker pull erlang

Listamos la imagen descargada:

$ docker images -a

Ejecutamos el REPL de Erlang:

$ docker run -it --rm erlang

Creamos un programa en Erlang.

holamundo.erl

% Hola mundo en Erlang
-module(holamundo).
-export([main/1]).

main(_Args) ->
    io:format("Hola, mundo!!~n").

Para ejecutar un script de Erlang:

$ docker run -it --rm --name erlang-inst1 -v "$PWD":/usr/src/myapp -w /usr/src/myapp erlang escript holamundo.erl

Hemos visto lo que es Docker y un ejemplo de como descargar una imagen (de Erlang).

En próximas entregas continuaremos con el tema.

Enlaces:

https://codemonkeyjunior.wordpress.com/2020/09/06/docker-instalando-imagen-de-php/
https://alquimistadecodigo.blogspot.com/2021/06/docker-aclarando-cosas.html
https://hub.docker.com/_/php
https://stackoverflow.com/questions/16047306/how-is-docker-different-from-a-virtual-machine

Terraform o Infraestructura cómo código

 

Según la Wikipedia, la Infraestructura como Código (Infrastructure as Code, en Inglés) es: el proceso de gestión y aprovisionamiento de centros de datos informáticos a través de archivos de definición legibles por máquina, en lugar de configuración de hardware físico o herramientas de configuración interactiva.

Básicamente:

• Es la capacidad de aprovisionar y respaldar su infraestructura de computación a través de código en lugar de procesos y configuraciones manuales.  
• Permite definir el estado deseado de su infraestructura sin incluir todos los pasos para llegar a ese estado.
• Automatiza la administración de la infraestructura para que los desarrolladores puedan centrarse en crear y mejorar las aplicaciones en lugar de administrar los entornos.

Enfoques diferentes de la infraestructura como código

Declarativa

La IaC declarativa permite al desarrollador describir los recursos y la configuración que componen el estado final de un sistema deseado.

A continuación, la solución de IaC crea este sistema a partir del código de infraestructura. Esto hace que la IaC declarativa sea fácil de usar, siempre que el desarrollador sepa qué componentes y configuraciones necesita para ejecutar su aplicación.

Imperativa

La IaC imperativa permite al desarrollador describir todos los pasos para configurar los recursos y llegar al sistema y al estado de ejecución deseados.

Si bien no es tan sencillo escribir la IaC imperativa como la IaC declarativa, el enfoque imperativo se hace necesario en las implementaciones de infraestructuras complejas. Esto es especialmente cierto cuando el orden de los eventos es crítico.

¿Qué es Terraform?

Terraform es una herramienta de Infraestructura como Código (IaC) que permite definir, provisionar y gestionar infraestructura en la nube o en entornos locales mediante archivos de configuración.

Estos archivos, escritos en un lenguaje declarativo llamado HashiCorp Configuration Language (HCL), describen los recursos y servicios que se quieren desplegar, como servidores, redes, bases de datos, entre otros.

Terraform es capaz de interactuar con múltiples proveedores de servicios en la nube (como AWS, Azure, Google Cloud) y otras plataformas, facilitando la creación y modificación de infraestructuras complejas de forma eficiente.

Se relaciona con IaC porque permite automatizar y versionar la infraestructura de la misma manera que se gestiona el código de software, asegurando que las configuraciones sean reproducibles, auditables y escalables.

Instalando Terraform

En Linux:

Abrimos una terminal y escribimos estos comandos:

# Actualizar paquetes
sudo apt-get update && sudo apt-get install -y gnupg software-properties-common

# Añadir repositorio oficial de HashiCorp:

wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list

# Instalar Terraform
sudo apt-get update && sudo apt-get install terraform

# Verificar instalación
terraform -v

Tendremos instalado Terraform en Linux.

En Mac OS:

Abrimos una terminal y escribimos estos comandos:

# Instala Terraform con Homebrew:
brew tap hashicorp/tap

brew install hashicorp/tap/terraform

terraform -v

Tendremos instalado Terraform en Mac OS.

En Windows:

Para esto es necesario contar con Chocolatey instalado en nuestras máquinas:

choco install terraform

Verificamos la instalación:

terraform -v

Tendremos Terraform instalado.

Ahora imaginemos que queremos crear una instancia de EC2 en AWS. Usaremos Terraform para lograrlo. La extensión del programa será *.tf

main.tf

# Especifica el proveedor de nube, en este caso AWS
provider "aws" {
  region = "us-east-1"  # Región donde se va a desplegar la infraestructura
}

# Definir una clave SSH para conectarse a la instancia
resource "aws_key_pair" "example" {
  key_name   = "example-key"
  public_key = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC3..."  # Llave pública SSH
}

# Crear una instancia de EC2 en AWS
resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"  # Identificador de la AMI (Amazon Machine Image)
  instance_type = "t2.micro"  # Tipo de la instancia

  # Configurar la clave SSH para la instancia
  key_name = aws_key_pair.example.key_name

  tags = {
    Name = "Terraform Example Instance"  # Etiqueta para identificar la instancia
  }
}

# Salida para ver la IP pública de la instancia creada
output "instance_public_ip" {
  value = aws_instance.example.public_ip
}

1. Inicializamos el proyecto:

$ terraform init

2. Previsualizar los cambios (plan):

$ terraform plan

3. Aplicar cambios:

$ terraform apply

4. Destruir la infraestructura (cuando ya no sea necesaria):

$ terraform destroy

Hemos dado una breve explicación de lo que es IaC y cómo se relaciona con Terraform.

Enlaces:

https://chocolatey.org/
https://www.terraform.io/

Cosas por aprender... cosas nuevas por aprender

 

Quien se dedique a la programación debería saber que SIEMPRE HAY ALGO NUEVO QUE APRENDER.  Quien ose de creer que lo sabe todo en un futuro estará obligado (quiera o no) a demostrar que así es. Lo que antes era moda hoy es casi "obsoleto" (VB .Net, PHP, Delphi, Informix, etc.). Cosas como Docker, Kubernetes, Terraform, gRPC y demás cosas son lo de hoy. Y llegará un futuro en el que vendrán otros a decir "Esto es lo de hoy, olvídate del pasado". 

El programador incipiente dirá cosas como: "¡No puede ser! ¡Apenas estoy aprendiendo a programar en Angular y ya salió su reemplazo!"

Y es que las cosas son así: Evolucionas o te estancas. 

"Pepepero, ¿Debo aprender todo lo que salga? ¿Debo convertirme en un Todologo?" 

Dirán tanto el programador incipiente y como experto. Y la respuesta más discordante y neurótica será: Si y no. Si, porque debes familiarizarte con lo actual. No, porque es imposible saber al 100% algo. Es bueno saber que existe X o Y cosa, y mejor si se puede especializarse en algo. Muy difícil sería saberlo todo (nadie lo sabe todo aunque así lo crea).

Y no todo es sobre programación

También debemos aprender a comunicarnos. Saber escribir, saber leer correctamente. Saber como comunicar nuestras ideas. Saber como resolver cosas antes de que éstas ocurran.

El modelado de sistemas, procesos, etc. también es muy útil. El programador debe saber modelar, esto para evaluar si la organización para la que trabajas está logrando sus objetivos y si está satisfaciendo las necesidades de sus clientes.

En está época donde las IAs están siendo cada vez más populares el programador o quien trabaja con grandes cantidades de información debe familiarizarse con ellas o comenzar a pensar a que se dedicara en un futuro, pues nada se detiene, todo avanza y cambia. El que no vaya a la misma velocidad quedará atrás de todos.

¿Y qué con otros idiomas?

En este post ya hablamos un poco de la importancia de los idiomas (entre otras cosas).  Saber más de un idioma es indispensable en el mundo de informática. Ya sea para leer y entender documentación o hablar con clientes o usuarios. Incluso para exponer proyectos, crear manuales, o resolver incidencias.

Saber un idioma extra al que ya hablas es una ventaja. Saber más de 3 idiomas te pone arriba de otros. Y si hablas más de 3 o 6 podrías trabajar en cualquier parte del mundo, sobre todo si entre éstos son Inglés, Alemán , Koreano o Mandarín.

Certificaciones

Una certificación no te hace experto en algo. Indica que sabes ciertas cosas, solo eso. La experiencia muchas veces es lo que te ayuda a resolver problemas, no un papel. 

Es bueno tener certificaciones si tu trabajo lo requiere. Si eres programador Backend una certificación en Consumo y creación de APIs es un plus para tu carrera. Y si eres más de administración, tener certificaciones en Gestión de proyectos te abrirá otras puertas.

Todos los días podemos aprender cosas nuevas o reforzar lo que ya sabemos (o creemos saber).

Solo basta abrir un poco los ojos y ver en qué podemos mejorar. 

Progressive Delivery con Kubernetes y Argo Rollouts - Por Orlando Valdez...

Ballerina en ejemplos

Ballerina es un lenguaje de programación de código abierto para la nube que facilita el uso, la combinación y la creación de servicios de red. A primera vista recuerda a lenguajes como Java y o Typescript. Ballerinta maneja tipos básicos como in, float, string, boolean, etc. La síntaxis de estructuras de control secuencial e iterativa son similares a Java. La extensión de un programa es *.bal
En post anteriores hemos hablado sobre Docker. En este post usaremos una imagen de Ballerina y la descargaremos con Docker.

$ docker pull ballerina/ballerina
$ docker images

Para compilar y ejecutar un programa escribimos este script bash:
ejecuta.sh

#!/bin/bash

# Mostramos el nombre del programa a compilar y ejecutar
echo "Ejecutamos $1"
docker run -v `pwd`:/home/ballerina -it ballerina/ballerina:1.0.2 ballerina build $1
docker run -v `pwd`:/home/ballerina -it ballerina/ballerina:1.0.2 ballerina run $1

Para usar el script es necesario darle permiso de ejecución y pasar el nombre del programa como argumento de entrada:

$ sudo chmod +x ejecuta.sh
$ ./ejecuta.sh programa.bal

Comencemos con algunos ejemplos.

Ejemplo. El clásico programa de "Hola, mundo".
holamundo.bal

import ballerina/io;

public function main(string... args) {
    io:println("Hola en Ballerina!!");
 
}

Compilamos y ejecutamos:

$ ./ejecuta.sh holamundo.bal

Ejemplo. Obtener el mayor de tres número enteros.
mayor_tres_numeros.bal

import ballerina/io;

public function main(string... args) {
	int a = 4;
	int b = -32;
	int c = 1;
	int mayor = a; 
        io:println("Numeros:\na:",a,",b:",b,",c:",c);
	if(mayor < b){
	  mayor = b;
	}
	if(mayor < c){
	  mayor = c;
	}
	io:println("mayor:",mayor);
}
    

Compilamos y ejecutamos:

$ ./ejecuta.sh mayor_tres_numeros.bal

Ejemplo. Crear dos funciones, una para sumar y otra para multiplicar dos números enteros.
funciones.bal

import ballerina/io;

public function sumar(int a, int b) returns int {
    return a + b;
}

public function multiplicar(int a, int b) returns int {
    return a * b;
}

public function main(string... args) {
        int a=7;
	int b=5;
	io:println("Suma de 5 y 7 es: ",sumar(a,b));
	io:println("Producto de 5 y 7 es: ",multiplicar(a,b));   
}

Compilamos y ejecutamos:

$ ./ejecuta.sh funciones.bal

¿Qué podemos analizar con estos ejemplos?

io:println("Hola en Ballerina!!");

Con esta instrucción imprimimos a pantalla.

int entero = 34;
io:println("Entero: ",entero);

Las instrucciones deben terminar con ;
Además se debe respetar el tipo de dato (esto no es Javasript u otro lenguaje de tipado dinámico).  Las funciones pueden o no devolver valores, si devuelven deben llevar la palabra returns en la cabecera indicando el tipo a devolver y return para devolver el valor calculado.
 

Ejemplo. Crear un programa que haga uso de sentencias iterativas con for y while.
bucles.bal

import ballerina/io;

public function main(string... args) {
        io:println("Elemento 0: ",numeros[0]);//1
	io:println("Elemento 5: ",numeros[5]);//6
        io:println("Tamaño: ",numeros.length());//8
	foreach var num in numeros{
		io:println("Elemento: ",num);
	}
	io:println("======================================");
	foreach var i in 0...9 {
        io:println("Numero: ",i);    
    }  
	io:println("======================================");
	int cont=0;
	while (cont < 10) {
        io:println("Cont: ",cont);
        cont = cont + 1;
    }

}

Compilamos y ejecutamos:

$ ./ejecuta bucles.bal

Como se puede ver la síntaxis es casi idéntica a la de Java y/o C#. Para quienes tienen cierta experiencia programando en lenguajes similares se les facilitará aprenderlo.
En próximos post veremos más ejemplos.
Enlaces:
https://alquimistadecodigo.blogspot.com/2020/09/docker-instalando-ballerina.html
https://ballerina.io/