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/

Las leyes (no escritas) de la programación (4ta parte)

En un mundo donde la I.A. ha dejado de ser un sueño o fantasía y es usada por la mayoría de las empresas de tecnología e IT el programador deberá saber adaptarse o morir.

Sin embargo, ¿La I.A. supone la muerte de la programación? No, ¡claro que no!

Quien quiera programar deberá saber programar. Así como quien quiera ser escritor deberá saber escribir.

Muchos creen que usar ChatGPT, Copilot, DeepSeek o cualquier otra inteligencia artificial automáticamente los convertirá en programadores. Se equivocan. Quien crea eso terminará dándose de topes en la pared cuando se enfrente a problemas de programación reales. No sabrá como resolverlos cuando la I.A. arroje resultados erróneos o inútiles.

He visto personas que creen que ChatGPT les resolverá todos sus bugs o creará de la nada sus proyectos. Y es por qué no conocen cómo funciona la I.A.

La I.A. no piensa, imita la forma de pensar. Carece de conciencia aunque nos quieran decir lo contrario. No es un Skynet, pero sus creadores lo harán parecer que sí.

Y tampoco es "gratis", ya que el producto final es quien la usa: nosotros.

Y nosotros somos quien la alimentamos, quien le damos retroalimentación, la "entrenamos" de acuerdo a lo que le pedimos, a lo que se le solicita.

ChatGPT, DeepSeek, Grok, etc. accede a sitios web, repositorios de código, base de datos propias para "crear" las respuestas a las solicitudes del usuario.

Lo cual es muy sospechoso. Es como si se hubiesen puesto de acuerdo para que funcionara así. Pues es capaz de recolectar datos de casi cualquier lado en la Internet.

Y también es sospechoso que antes del auge de las I.A. la malévola empresa Microsoft compró Github.😱

Pero, ¿Qué significa adaptarse? Significa que:

• Recordar que los fundamentos nunca deben dejarse en saco roto. 
• Mantener el código lo más simple y claro posible.
• Actualizarse constantemente.  
• No dejar de practicar y conocer nuevos temas. 
• Usar la I.A. a favor y no en contra.
• Saber qué solicitar y saber qué no es útil.

Esperemos que pasa en el futuro.

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/01/las-leyes-no-escritas-de-la.html
https://codemonkeyjunior.blogspot.com/2025/06/vibe-coding-la-programacion-via-ia-el.html

Programando en C++ no. 5 (manejo de excepciones)

El manejo de excepciones nos ayuda a que el flujo normal de nuestros programas no se vea interrumpido. C++ tiene mecanismos similares a lenguajes como Java y/o C# para realizar esta tarea.

Una excepción ocurre cuando hay un problema en alguna instrucción de nuestro programa, ya sea por que accedemos a una variable sin asignación de valor y que de por resultado un null. Un acceso a un método en un momento inoportuno. Una conversión numérica que no cumple las condiciones adecuadas. Acceder a un elemento que no existe en un arreglo o matriz.

Nosotros podríamos provocar una excepción con toda intencionalidad. Veamos un ejemplo:

excepcion.cpp

#include <iostream>

int main() {
  try {
    throw 0.0;
  }
  catch(double ex){
    std::cout << "Excepcion de tipo double: " << ex << std::endl;
  }
}

Compilamos y ejecutamos:

$ g++ excepcion.cpp -o excepcion.exe
$ excepcion.exe

¿Qué queremos decir en este programa?

El bloque ``try-catch`` se encargará de lanzar (throw) una excepción para luego cacharla (catch). En este caso provocamos la excepción que es un valor 0.0 (tipo double) y la excepción deberá ser del mismo tipo.

En otras palabras:

• try: define el código a probar, es decir, es el cuerpo del código donde puede ocurrir una excepción.
• throw: activa o lanza una excepción. 
• catch: maneja o atrapa el error.

Veamos las siguientes excepciones hechas en Java:

try{
    int divide = 2/0;
}catch(ArithmeticException ex){
    ex.printStackTrace();
}


int[] arreglo = {1,2,3};
try{
    int numero = arreglo[3];
}
catch(ArrayIndexOutOfBoundsException ex){
    ex.printStackTrace();
}
catch(Exception ex){
    ex.printStackTrace();
}


try{
    int entero = Integer.parseInt("23f");
}catch(NumberFormatException ex){
    ex.printStackTrace();
}


String cadena = null;
try{
    boolean vacio = cadena.isEmpty();
}catch(NullPointerException ex){
    ex.printStackTrace();
}

Tipos de excepciones que vemos:

• ArithmeticException: cuando tratamos de hacer una operación aritmética inválida. En este caso una división por cero. 
• ArrayIndexOutOfBoundsException: al tratar de acceder a un índice inexistente de un arreglo. 
• NumberFormatException: intentar convertir una cadena a número, pero la cadena no cumple el formato numérico. 
• NullPointerException: acceder a un elemento null.

El código equivalente en C++ sería algo como esto:

excepciones.cpp

#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

int main() {
    // División por cero simulada
    try {
        int divisor = 0;
        if (divisor == 0) throw std::runtime_error("División por cero detectada.");
        int divide = 2 / divisor;
        std::cout << "Resultado: " << divide << std::endl;
    } catch (const std::exception& ex) {
        std::cerr << "[División] Excepción: " << ex.what() << std::endl;
    }

    // Acceso fuera de los límites del arreglo
    try {
        std::vector<int> arreglo = {1, 2, 3};
        int numero = arreglo.at(3); // índice fuera de rango
        std::cout << "Número: " << numero << std::endl;
    } catch (const std::out_of_range& ex) {
        std::cerr << "[Arreglo] Excepción: " << ex.what() << std::endl;
    } catch (...) {
        std::cerr << "[Arreglo] Otra excepción inesperada." << std::endl;
    }

    // Conversión inválida de cadena a entero
    try {
        std::string texto = "f23f";
        int numero = std::stoi(texto);
        std::cout << "Número convertido: " << numero << std::endl;
    } catch (const std::invalid_argument& ex) {
        std::cerr << "[Conversión] Excepción: " << ex.what() << std::endl;
    }

    // Puntero nulo accediendo a método
    try {
        std::string* cadena = nullptr;
        if (!cadena) throw std::runtime_error("Cadena nula.");
        bool vacio = cadena->empty();
        std::cout << "¿Está vacía?: " << std::boolalpha << vacio << std::endl;
    } catch (const std::exception& ex) {
        std::cerr << "[Cadena nula] Excepción: " << ex.what() << std::endl;
    }

    return 0;
}

Compilamos y ejecutamos:

$ g++ excepciones.cpp -o excepciones.exe
$ excepciones.exe

Salida:

[Divisi├│n] Excepci├│n: Divisi├│n por cero detectada.
[Arreglo] Excepci├│n: vector::_M_range_check: __n (which is 3) >= this->size() (which is 3)
[Conversi├│n] Excepci├│n: stoi
[Cadena nula] Excepci├│n: Cadena nula.

¡Hemos visto como crear excepciones en C++!

Continuaremos con este tema en próximas entregas sobre este lenguaje.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/06/hace-tiempo-vimos-como-crear-un.html
https://hektorprofe.github.io/cpp/13-manejo-excepciones/
https://isocpp.org/wiki/faq/exceptions
https://www.w3schools.com/cpp/cpp_exceptions.asp

Programando en C# no. 8 (manejo de excepciones)

En el mundo de la programación hay que saber diferenciar entre una excepción y un error.

Una excepción es una falla en el flujo normal de un programa. Si el programa tiene manejo de excepciones, el programa continuará su ejecución o flujo aunque hayan excepciones. Un ejemplo sería que en una parte del prograam se quiera acceder a un índice inexistente de un vector.

Un error es una falla que romperá el flujo del programa. No hay forma de evitarlo. Por ejemplo, que la máquina en la que se está ejecutando un programa se quede sin memoria o que no tenga energía (eléctrica) para funcionar.

Al igual que Java, C# tiene la capacidad de manejar excepciones. Casi de manera idéntica.

Supongamos que queremos acceder a un índice de una cadena "ABC" que no existe. La forma de manejar esa excepción, de tipo ArgumentOutOfRangeException, sería la siguiente:

 try
 {
   string nuevoString = "ABC".Substring(2, 4);
   Console.WriteLine("{0}", nuevoString);
 } catch (ArgumentOutOfRangeException aoex)
  {
    Console.WriteLine("Ha ocurrido una Excepcion: {0}", aoex.Message);
  }

Al compilar no ocurrirá ningún error. La excepción se lanzará a la hora de la ejecución:

Ha ocurrido una Excepcion: Index and length must refer to a location within the string. (Parameter 'length')

Con esto el programa continuará su flujo a pesar de la excepción.

Para operaciones aritméticas haríamos algo como esto (ArithmeticException): 

var x = 1;
var y = 0;
try
{
  int divide = x / y;
}
catch (ArithmeticException ex)
{ 
  Console.WriteLine("Ha ocurrido una Excepcion: {0}", ex.Message);
}

De igual manera, no ocurrirá nada a la hora de la compilación. Ocurrirá a la hora de ejecución:

Ha ocurrido una Excepcion: Attempted to divide by zero.

Ya que se trata de una división entre cero.

Supongamos que queremos acceder a un elemento inexistente de un arreglo (o vector):

int[] arreglo = { 1, 2, 3 };
try
{
   int numero = arreglo[3];
}
catch (IndexOutOfRangeException ex)
{
  Console.WriteLine("Ha ocurrido una Excepcion: {0}", ex.Message);
}

El compilador no adivinará que queremos acceder a un índice que no existe. Sin embargo, el manejo de la excepción, de tipo IndexOutOfRangeException, se encargará de gestionar esa acción.

Ha ocurrido una Excepcion: Index was outside the bounds of the array.

Nota: Existen excepciones marcadas y no marcadas. Las marcadas son las que el compilador obliga a escribir. Las no marcadas no requieren manejo explícito, pero pueden causar la terminación del programa.

Continuaremos con esta serie de entregas sobre C#.

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/07/programando-en-c-no-7-uso-de-genericos.html

GCP Pub/Sub: un servicio de mensajería asíncrona y escalable

Según la documentación oficial, Pub/Sub es:

Un servicio de mensajería asíncrona y escalable que separa los servicios que producen mensajes de aquellos que procesan esos mensajes.

Lo que nos permite hacer es:

Permitir que los servicios se comuniquen de forma asíncrona, con latencias de alrededor de 100 milisegundos.

Se usa para:

Las canalizaciones de integración de datos y estadísticas de transmisión a fin de cargar y distribuir datos. Es igual de efectivo que el middleware orientado a la mensajería para la integración de servicios o como una cola con el fin de paralelizar las tareas.

Pub/Sub te permite crear sistemas de productores y consumidores de eventos, llamados publicadores y suscriptores. Los publicadores se comunican con los suscriptores de forma asíncrona mediante la transmisión de eventos, en lugar de llamadas de procedimiento remoto (RPC) síncronas.

Los publicadores envían eventos al servicio de Pub/Sub, sin importar cómo o cuándo se procesarán estos eventos. Luego, Pub/Sub entrega eventos a todos los servicios que reaccionan a ellos. En los sistemas que se comunican a través de RPC, los publicadores deben esperar a que los suscriptores reciban los datos.

Sin embargo, la integración asíncrona en Pub/Sub aumenta la flexibilidad y solidez del sistema general.

En pocas palabras, es una tecnología similar a RabbitMQ, Apache Kafka y/o ActiveMQ por mencionar solo algunas.

Casos habituales

• Transferir la interacción del usuario y los eventos del servidor. 
• Distribución de eventos en tiempo real. 
• Replicar datos entre bases de datos. 
• Procesamiento y flujos de trabajo paralelos. 
• Bus de eventos empresariales. 
• Transmisión de datos desde aplicaciones, servicios o dispositivos de la IoT. 
• Actualización de cachés distribuidas. 
• Balanceo de cargas para la confiabilidad.

Un ejemplo sencillo de esta tecnología sería crear una aplicación que:

• Publique mensajes a un tópico de Pub/Sub y 
• Reciba mensajes desde ese tópico.

Para ello es necesario tener una cuenta de GCP. Tener el JDK más actual.

Creamos una aplicación de Spring Boot y en nuestro pom.xml agregamos la siguiente dependencia:

<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>spring-cloud-gcp-starter-pubsub</artifactId>
</dependency>

La configuración del archivo YAML sería algo como esto:

# En application.yml
spring:
  cloud:
    gcp:
      pubsub:
        project-id: tu-id-de-proyecto
        credentials:
          location: classpath:tu-archivo-de-credenciales.json

Crearemos una clase tipo Service que servirá como el "publicador":

@Service
public class PublisherService {
    private final PubSubTemplate pubSubTemplate;

    public PublisherService(PubSubTemplate pubSubTemplate) {
        this.pubSubTemplate = pubSubTemplate;
    }

    public void enviarMensaje(String mensaje) {
        pubSubTemplate.publish("mi-topico", mensaje);
    }
}

Crearemos una clase tipo Component que servirá para escuchar los mensajes:

@Component
public class Subscriber {
    @PubSubSubscriber(subscription = "mi-suscripcion")
    public void recibirMensaje(String mensaje) {
        System.out.println("Mensaje recibido: " + mensaje);
    }
}

Ahora crearemos una clase tipo Controller para invocar el método de envío de mensajes:

@RestController
@RequestMapping("/pubsub")
public class PubSubController {

    private final PublisherService publisherService;

    public PubSubController(PublisherService publisherService) {
        this.publisherService = publisherService;
    }

    @PostMapping("/enviar")
    public ResponseEntity<String> enviar(@RequestBody String mensaje) {
        publisherService.enviarMensaje(mensaje);
        return ResponseEntity.ok("Mensaje publicado: " + mensaje);
    }
}

Usando curl para probar el mensaje:

curl -X POST http://localhost:8080/pubsub/enviar \
     -H "Content-Type: text/plain" \
     -d "Hola desde el controlador!"

También agregando un nuevo método en el controller:

@PostMapping("/enviar-json")
public ResponseEntity<String> enviarJson(@RequestBody Map<String, String> payload) {
    String mensaje = payload.get("mensaje");
    publisherService.enviarMensaje(mensaje);
    return ResponseEntity.ok("Mensaje JSON publicado: " + mensaje);
}

Y usando curl:

curl -X POST http://localhost:8080/pubsub/enviar-json \
     -H "Content-Type: application/json" \
     -d '{"mensaje": "¡Hola JSON!"}'

Continuaremos sobre temas de GCP en próximas entregas.

Enlaces:

https://cloud.google.com/pubsub/docs/overview
https://www.rabbitmq.com/
https://kafka.apache.org/
https://activemq-apache-org.translate.goog/

Programando en C# no. 7 (uso de genéricos)

En el mundo de la programación un genérico nos permite escribir código que trabaja con cualquier tipo de datos sin perder la seguridad de tipos. Es una forma de crear clases, interfaces y métodos que pueden operar sobre varios tipos de datos sin duplicar código. Esto evita castings innecesarios y errores en tiempo de ejecución, ofreciendo reutilización y robustez.

Suponiendo que tenemos esta clase:

public class Caja<T> {
    private T contenido;

    public void Guardar(T elemento) {
        contenido = elemento;
    }

    public T Obtener() {
        return contenido;
    }
}

Lo usaríamos de la siguiente forma:

Caja<int> cajaDeEnteros = new Caja<int>();
cajaDeEnteros.Guardar(42);
Console.WriteLine(cajaDeEnteros.Obtener());  

El tipo T se puede cambiar por cualquier clase o tipo primitivo, lo que lo vuelve extremadamente flexible. Si hacer ninuna conversión o casteo (cast). Veamos otro uso:

var myTypeFloat = new Caja<float>();
myTypeFloat.Guardar(232.0f);
Console.WriteLine("Float: {}", myTypeFloat.Obtener());

var myTypeString = new Caja<string>();
myTypeString.Guardar("232");
Console.WriteLine("String: {}", myTypeString.Obtener());

Usar genéricos nos ahorra tener que hacer conversiones, casteos o incluso crear clases por tipos. ¿Se podrá usar con interfaces? La respuesta es sí.

public interface MyInterface<T> {
        T suma(T num1, T num2);
}

Podríamos crear una clase que lo implemente, además específicamos el tipo a usar, en este caso será un BigInteger.

public class MyInterfaceImpl : MyInterface<BigInteger>
    {
        public BigInteger suma(BigInteger x, BigInteger y)
        {
            return x + y;
        }
    }

Creamos unas variables tipo ``BigInteger`` y se las pasamos al método de suma:

BigInteger x = new BigInteger(23);
var y = new BigInteger(45);
var myInterface = new MyInterfaceImpl();
var resultSuma = myInterface.suma(x, y);
Console.WriteLine("Suma: {}", resultSuma); 

Al final mostramos el resultado de la suma.

Este solo es un ejemplo del uso de clases e interfaces genéricas. Continuaremos con esta serie sobre C# en próximas entregas.

Enlaces:

https://emanuelpeg.blogspot.com/search/label/C%23
Aprender a programar con C# (Libro)