El creador de Wisp, Louis Pilfol, nos ofrece un vistazo a su framework desde su canal del Youtube (https://www.youtube.com/@lpil).
Recordemos que ya hemos hablado de el en este blog. Se trata de un nuevo framework para desarrollo web empleando el lenguagle Gleam. Un lenguaje inspirado en Elixir.
Enlaces:
http://codemonkeyjunior.blogspot.com/2025/04/wisp-un-nuevo-framework-para-gleam.html
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
_logo.png/330px-Docker_(container_engine)_logo.png){kind=logo}
Docker ofrece:
$ wsl --update
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.
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:
Las diferencias con respecto a Kubernetes son:
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:
Diferencias con Kubernetes:
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:
Diferencias respecto a Kubernetes:
Mesos es versátil para entornos mixtos y big data; Kubernetes es el estándar para contenedores y microservicios modernos.
| 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/
En un anterior post hablamos sobre Nuget. El cual es el administrador de paquetes para .NET.
Con Nuget podemos:
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/
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.
Requisitos:
Para instalarlo, puedes ir a este sitio y descargarlo:
https://github.com/helm/helm/releases/tag/v3.18.5Tambié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:
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
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:
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:
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/El creador de Wisp, Louis Pilfol, nos ofrece un vistazo a su framework desde su canal del Youtube ( https://www.youtube.com/@lpil ). ...
