GCP: manejo de excepciones en BigQuery

 

El manejo de excepciones es un mecanismo para identificar, tratar y recuperar el flujo normal de un programa en ejecución. El lenguaje de BigQuery nos permite gestionar los errores cuando estos ocurren  en nuestras consultas SQL. Miremos unos ejemplos.

El siguiente bloque de BigQuery tratará de ejecutar una consulta a una tabla que no existe (tabla_no_existente). El sub-bloque tiene un manejo de excepción de tipo ``ERROR``.

DECLARE error STRING;
BEGIN
  BEGIN
     -- Primera consulta, fallará.
     SELECT * FROM mydataset.tabla_no_existente;
  EXCEPTION WHEN ERROR THEN
      SET error = 'Ha ocurrido una excepcion.';
      RAISE; -- Termina la ejecución de todo el bloque. La segunda consulta no se realizará.
   END;

   -- Segunda consulta.
   SELECT * FROM mydataset.tabla_existente LIMIT 1;
END;

Si queremos que la segunda consulta se ejecute aún si ocurre un error en la primera consulta, entonces tan solo quitamos la instrucción ``RAISE``, la cual se utiliza para generar explícitamente un error o reactivar una excepción existente.

Tendríamos lo siguiente:

DECLARE error STRING;
BEGIN
  BEGIN
     -- Primera consulta, fallará.
     SELECT * FROM mydataset.tabla_no_existente;
  EXCEPTION WHEN ERROR THEN
      SET error = 'Ha ocurrido una excepcion.';
   END;

   -- Segunda consulta. Se ejecuta aunque la primera haya fallado.
   SELECT * FROM mydataset.tabla_existente LIMIT 1;
END;

La primera consulta fallará, pero no se terminará la ejecución del bloque completo. Se ejecutará la segunda consulta.

¿Cómo obtener información detallada del error ocurrido?

Crearemos un Stored Procedure que nos permitirá mostrar a detalle el error en la ejecución de una consulta SQL en BigQuery.

CREATE OR REPLACE PROCEDURE `mydataset.exec_sp_error`(OUT error_flag STRING)
BEGIN
   -- Esta consulta fallará.
   SELECT usuario,* FROM mydataset.tabla_no_existente;

  EXCEPTION WHEN ERROR THEN
   SET error_flag = "Error: ";
   SET error_flag = concat(salida, @@error.message);
   SET error_flag = concat(salida, ". Causa: "); 
   SET error_flag = concat(salida, @@error.statement_text);  
END;

Invocamos el Stored Procedure y consultamos la variable ``error_flag``:

DECLARE error_flag STRING;
-- Invocamos el Stored Procedure
CALL`mydataset.exec_sp_error`(error_flag);
-- Mostrará el error a detalle
SELECT error_flag;

En lenguajes de programación como Java, C++ y C# se puede hacer algo como esto:

try{
   int divide = 1/0;
}catch(ArithmeticException ex){
   System.err.printf("%s\n", ex.getCause());
   System.err.printf("%s\n", ex.getMessage());
   ex.printStackTrace();
}

Lo cual disparará una excepción de tipo ``ArithmeticException``, pues no podemos dividir un número por cero.

En BigQuery el código equivalente sería:

BEGIN
  SELECT 1/0; -- División por cero. 
EXCEPTION WHEN ERROR THEN
  SELECT @@error.message AS error_message;
  SELECT @@error.stack_trace AS stack_trace;
  SELECT @@error.statement_text AS text_error;
END;

Cuando se lance la excepción se mostrará los errores en la consola de BigQuery.

Continuaremos sobre esta serie de BigQuery más adelante.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/11/stored-procedures-oracle-plsql-gcp.html
https://cloud.google.com/bigquery/docs/error-messages

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

Programando en C# no. 9 (usando Nuget)

En un anterior post hablamos sobre Nuget. El cual es el administrador de paquetes para .NET.

Con Nuget podemos:

1. Consumir paquetes de terceros. 
2. Crear nuestros paquetes. 
3.  Publicar nuestros paquetes.

Nuget está incluido en el .Net Core. Abriremos una consola y teclearemos lo siguiente:

$ mkdir codemonkey 
$ cd codemonkey
$ dotnet new console

Nos ubicaremos en el proyecto creado y listaremos los paquetes:

$ dotnet list package

Mostrará un mensaje indicando que no hay paquetes asociados al proyecto.

Si queremos instalar un paquete podemos hacerlo con Nuget.

El sitio https://www.nuget.org/ tiene un buscador de paquetes. Si queremos, por ejemplo, instalar un conector de BD de MySQL podemos buscarlo. Si lo encuentra, damos clic al enlace y nos mostrará la forma de instalarlo desde dotnet.

Instalando el paquete de MySQL:

$ dotnet add package MySqlConnector --version 2.4.0

Ahora listamos el paquete:

$ dotnet list package

El sitio también provee de ejemplos de cómo usarlo (en algunos paquetes):

// set these values correctly for your database server
var builder = new MySqlConnectionStringBuilder
{
	Server = "your-server",
	UserID = "database-user",
	Password = "P@ssw0rd!",
	Database = "database-name",
};

// open a connection asynchronously
using var connection = new MySqlConnection(builder.ConnectionString);
await connection.OpenAsync();

// create a DB command and set the SQL statement with parameters
using var command = connection.CreateCommand();
command.CommandText = @"SELECT * FROM orders WHERE order_id = @OrderId;";
command.Parameters.AddWithValue("@OrderId", orderId);

// execute the command and read the results
using var reader = await command.ExecuteReaderAsync();
while (reader.Read())
{
	var id = reader.GetInt32("order_id");
	var date = reader.GetDateTime("order_date");
	// ...
}

Para ASP .Net tendríamos:

var builder = WebApplication.CreateBuilder(args);

// use AddMySqlDataSource to configure MySqlConnector
builder.Services.AddMySqlDataSource(builder.Configuration.GetConnectionString("Default"));

var app = builder.Build();

// use dependency injection to get a MySqlConnection in minimal APIs or in controllers
app.MapGet("/", async (MySqlConnection connection) =>
{
    // open and use the connection here
    await connection.OpenAsync();
    await using var command = connection.CreateCommand();
    command.CommandText = "SELECT name FROM users LIMIT 1";
    return "Hello World: " + await command.ExecuteScalarAsync();
});

app.Run();

Nuget nos permite encontrar, agregar y compartir paquetes para nuestras aplicaciones. Como desarrolladores sabemos que muchas veces un paquete puede ahorrarnos horas o días (e incluso más tiempo) de desarrollo.

Ejemplo. Queremos hacer una sencilla gráfica, pero nos llevaría bastante tiempo crear un paquete que nos permita hacerlo. La solución sería buscarlo e instalarlo.

La opción ideal sería ScottPlot, ya que es una biblioteca de gráficos similar a Matplotlib. La cual ofrece un equilibrio ideal entre facilidad de uso, rendimiento, integración nativa y documentación extensa. Eso es lo que buscamos.

La instalaremos:

$ dotnet add package ScottPlot --version 5.0.55

Si la instalación fue correcta, saldrá un mensaje indicando que ya lo tenemos integrado a nuestro proyecto. Usaremos el código de ejemplo:

Program.cs

double[] dataX = { 1, 2, 3, 4, 5 };
double[] dataY = { 1, 4, 9, 16, 25 };

ScottPlot.Plot myPlot = new();
myPlot.Add.Scatter(dataX, dataY);
myPlot.SavePng("quickstart.png", 400, 300);

Código completo:

Program.cs

using System;
using ScottPlot;


class Program
{

    public static void Main(string[] args)
    {
        Test();
    }


   private static void Test()
   {
       double[] dataX = { 1, 2, 3, 4, 5 };
       double[] dataY = { 1, 4, 9, 16, 25 };

       ScottPlot.Plot myPlot = new();
       myPlot.Add.Scatter(dataX, dataY);
       myPlot.SavePng("quickstart.png", 400, 300);
       Console.WriteLine("Gráfico creado.");
   }

}

Compilamos y ejecutamos:

$ dotnet build
$ dotnet run

Si ejecutó correctamente la aplicación, entonces se creará un gráfico llamado ``quickstart.png``.

En conclusión, si eres desarrollador .NET, entonces con Nuget encontrarás los paquetes necesarios para tus aplicaciones.

Enlaces:

https://www.nuget.org/
https://learn.microsoft.com/es-es/nuget/what-is-nuget
https://codemonkeyjunior.blogspot.com/2019/06/instalar-paquetes-nuget-con-dotnet.html

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

Apache Camel: un framework para integración de sistemas y datos

 

Apache Camel es un framework de integración de código abierto basado en Java que facilita la conexión y comunicación entre diferentes sistemas, aplicaciones o servicios mediante patrones de integración empresarial (EIP). Permite definir rutas de procesamiento de mensajes de forma sencilla, soportando múltiples protocolos y formatos de datos. Además de integraciones más complejas, como conectar APIs o bases de datos.

Nos sirve para:

• Integración de sistemas: Conecta aplicaciones heterogéneas (ej. bases de datos, APIs, colas de mensajes). 
• Transformación de datos: Convierte formatos (XML, JSON, etc.). 
• Enrutamiento de mensajes: Dirige datos entre sistemas según reglas definidas. 
• Soporte de protocolos: Integra con HTTP, FTP, JMS, Kafka, y más.
• Automatización: Simplifica flujos de trabajo complejos.

Aunque está diseñado principalmente para entornos Java y se integra bien con aplicaciones basadas en JVM, también soporta otros lenguajes y entornos gracias a su flexibilidad y componentes.

Hagamos un sencillo ejemplo. Un simple "Hola, mundo". Primero debemos tener instalado:

1. JDK 8 o una versión mayor. 
2. Maven en su última versión.

Crear un proyecto Maven y agregar esta dependencia al pom.xml:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <version>4.8.0</version>
</dependency>

Podemos crear el proyecto con estos comandos:

$ mvn archetype:generate -DgroupId=com.codemonkey -DartifactId=HolaMundo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Creamos una clase Java:

HolaMundoCamel.java

import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.main.Main;

public class HolaMundoCamel {
    public static void main(String[] args) throws Exception {
        Main camel = new Main();
        camel.configure().addRoutesBuilder(new RouteBuilder() {
            @Override
            public void configure() {
                from("timer:hello?period=2000")
                    .setBody(constant("Hola, Mundo"))
                    .to("log:output");
            }
        });
        camel.run();
    }
}

Construimos el proyecto:

$ mvn clean install

Ejecutamos:

$ mvn exec:java -Dexec.mainClass="HolaMundoCamel"

Cada 2 segundos se mostrará este mensaje:

[main] output INFO  Exchange[ExchangePattern: InOnly, Body: Hola, Mundo]

Apache Camel también se puede usar con Spring Boot y Quarkus.

Enlaces:

https://camel.apache.org/

OWASP: el Top Ten de las vulnerabilidades de tu aplicación web

OWASP(Open Web Application Security Project) es un proyecto de código abierto dedicado a determinar y combatir las causas que hacen que el software sea inseguro.

Su misión es mejorar la seguridad de las aplicaciones web mediante la concienciación, la educación y la promoción de las mejores prácticas de seguridad.

Este proyecto hace hincapié en un top ten de concientización para desarrolladores y seguridad de aplicaciones web. Básicamente, se trata de un documento que representa un amplio consenso sobre los riesgos de seguridad más críticos para las aplicaciones web.

El top ten de OWASP

El Top Ten de OWASP es una lista de las 10 vulnerabilidades de seguridad más críticas en aplicaciones web.

Aunque son en 10 se presenta un onceavo, ya que la lista no se limita y hay muchos aspectos de seguridad a tomar en cuenta.

Tema	Significado
A01:2021 – Broken Access Control	Control de Acceso Roto: Fallos en la gestión de permisos que permiten a usuarios no autorizados acceder a datos o funciones restringidas.
A02:2021 – Cryptographic Failures	Fallos Criptográficos: Uso inadecuado de cifrado, exponiendo datos sensibles como contraseñas o información personal.
A03:2021 – Injection	Inyección: Código malicioso (como SQL o comandos) insertado en entradas de usuario, comprometiendo sistemas o bases de datos.
A04:2021 – Insecure Design	Diseño Inseguro: Falta de principios de diseño seguro, lo que introduce vulnerabilidades desde la concepción de la aplicación.
A05:2021 – Security Misconfiguration	Configuración Incorrecta de Seguridad: Configuraciones débiles o predeterminadas en servidores, frameworks o aplicaciones.
A06:2021 – Vulnerable and Outdated Components	Componentes Vulnerables y Desactualizados: Uso de software obsoleto o con vulnerabilidades conocidas, como bibliotecas o frameworks.
A07:2021 – Identification and Authentication Failures	Fallas de Autenticación e Identificación: Errores que permiten a atacantes suplantar identidades o eludir autenticaciones.
A08:2021 – Software and Data Integrity Failures	Fallas en la Integridad de Datos y Software: Falta de validación de datos o software, permitiendo manipulaciones no autorizadas.
A09:2021 – Security Logging and Monitoring Failures	Fallas en el Registro y Monitoreo de Seguridad: Ausencia de logs adecuados o monitoreo, dificultando la detección de ataques.
A10:2021 – Server-Side Request Forgery (SSRF)	Falsificación de Peticiones del Lado del Servidor (SSRF): Ataques que inducen al servidor a realizar peticiones no autorizadas a sistemas internos o externos.
A11:2021 – Next Steps	Denegación de servicio entre otros.

Como programador, conocer el Top Ten de OWASP te sirve para:

• Prevenir vulnerabilidades: Identificar y corregir fallos comunes en el código (como inyecciones SQL o autenticación débil) antes de que se conviertan en problemas de seguridad. 
• Mejorar la seguridad de tus aplicaciones: Aplicar prácticas de desarrollo seguro, como validar entradas, usar cifrado adecuado y gestionar permisos correctamente. 
• Proteger datos sensibles: Evitar exposición de información de usuarios (contraseñas, datos personales) al mitigar riesgos como fallos criptográficos o SSRF. 
• Cumplir con estándares: Alinear tus proyectos con normativas de seguridad (como GDPR o PCI-DSS) y demostrar diligencia en auditorías. 
• Reducir riesgos de ataques: Disminuir la probabilidad de que tu aplicación sea explotada por atacantes, protegiendo la reputación y los recursos de tu organización. 
• Priorizar esfuerzos: Enfocarte en las vulnerabilidades más críticas y comunes, optimizando tiempo y recursos en el desarrollo. 
• Educarte y capacitarte: Mantenerte actualizado sobre amenazas emergentes y aprender mejores prácticas de codificación segura.

Enlaces:

https://owasp.org/
https://cheatsheetseries.owasp.org/index.html
https://es.securecodewarrior.com/