Pre-requisitos

Para nuestro laboratorio, vamos a utilizar una computadora x86 corriendo Ubuntu. Adicionalmente, es necesario tener Docker instalado utilizando las instrucciones oficiales.

Adicionalmente, es necesario contar con una cuenta en Docker hub (gratis)

Procedimiento

• Instalar QEMU en el sistema operativo

    apt install -y qemu-user-static
  

• Correr Binfmt en un contenedor

    docker run --privileged --rm tonistiigi/binfmt --install all
  

• Configurar Buildkit

    docker buildx create --use --name mymultiarchbuilder \
      --driver docker-container
  
    docker buildx inspect --bootstrap
  

• Iniciar sesión en Docker Hub

    docker login
  

• Crear el contenedor. Por favor note que es necesario reemplazar “<my username>” en el script con su username del Docker Hub

    docker buildx build \
            -t <my username>/mymultiarch:latest \
            --platform linux/386,linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64/v8,linux/ppc64le,linux/riscv64,linux/s390x,linux/arm64 \
            --push \
            -f - . <<EOF
                    FROM alpine:latest
                    # Install bash inside the image for all target platforms
                    RUN apk add bash
  
                    # Define the command that will run when the container starts
                    CMD ["sh", "-c", "echo 'Hola desde Arch: $(uname -m)' && /bin/bash"]
    EOF
  

• Inspeccionando la imagen

    docker buildx imagetools inspect <my username>/mymultiarch:latest
  

Pruebas

• Corra el contenedor en diferentes hardware en diferentes plataformas

    docker run --rm <my username>/mymultiarch:latest uname -m
  

Dependiendo de la plataforma desde la que ejecute el comando se mostrará la arquitectura en la que está corriendo el contenedor

Adicionalmente, puede abrir la imagen en Docker Hub y ver todas las plataformas que son soportadas por el contenedor

Conclusión

Es posible lograr que su software corra en varias plataformas logrando un rendimiento nativo gracias a la tecnología de cross compiling que permite lograr una verdadera multiarquitectura en donde su software no corre siendo emulado sino utilizando las instrucciones nativas que ofrece el procesador. De la misma manera, este tipo de contenedores pueden ser utilizados en clusters de Kubernetes que ofrecen capacidades de hospedaje híbrido, en donde usted podría por ejemplo correr su software en hardware x86 a la par de estaciones de trabajo Apple con procesadores de la serie M (arm64) de una forma completamente transparente.

Ventoy es una utilidad que nos permite no solo lograr este objetivo, sino hacerlo para una variedad de sistemas operativos limitada únicamente por la capacidad de la memoria USB que se utilice.

Pre-requisitos

Asegúrese de cumplir con los siguientes requisitos antes de crear su primer memoria USB multiboot:

1. Poseer una memoria USB (conector tipo A o C) que esté limpia o que pueda ser formateada sin riesgo a perder información valiosa.

2. Bajar la utilidad de Ventoy para Windows (archivo con la palabra “windows” en el nombre).

3. Bajar los archivos .iso para los sistemas operativos que desea poder arrancar con su memoria USB. Estos son algunos ejemplos que considero útiles no solo para nuevas instalaciones, sino para casos de emergencia también:

   • Hiren’s BootCD: Colección de herramientas para diagnosticar y reparar su computadora.

   • SystemRescueCD: Provee un ambiente de rescate y diagnóstico exhaustivo en casos de emergencias.

   • Clonezilla: Para clonado de discos e imágenes.

   • GParted Live: Un poderoso editor de particiones.

   • Nano11 y Tiny11: Versiones minimizadas y optimizadas de Windows.

   • Proxmox: Solución poderosa para la creación de ambientes virtualizados.

   • Ubuntu Server: Distribución popular de Linux para servidores basada en Debian.

   • Linux Mint: Distribución popular de Linux para computadoras de escritorio basada en Ubuntu (y a su vez Debian)

Procedimiento

Instalación de Ventoy

• El primer paso es conectar su memoria USB a su computadora

• Lo siguiente es descomprimir el .zip de Ventoy y correr el archivo Ventoy2Disk.exe

  

• Presione el botón “Install” y espere a que la instalación de Ventoy se complete.

• Una vez completada la instalación, Windows mostrará una nueva unidad con el nombre “Ventoy”. Usted puede en este momento copiar los archivos .iso/.img/.wim/.vhd a esta nueva unidad.

  

Probando su nueva memoria USB multiboot

• En este punto, debe reiniciar su computadora y configurar el BIOS para que pueda arrancar utilizando el USB drive como primer dispositivo de arranque. Una explicación detallada de este proceso está fuera del dominio de este artículo.

• Una vez que todo sea configurado apropiadamente, podrá ver el menú de arranque de Ventoy con las entradas correspondientes para las imágenes que haya copiado a memoria USB.

  

Conclusión

Ventoy nos permite crear memorias USB con la capacidad de arrancar diferentes sistemas operativos utilizando un solo dispositivo físico. Este tipo de herramienta es muy útil en casos de emergencia o simplemente para instalar/reinstalar un sistema operativo en una computadora.

Pre-requisitos

El soporte para PQC (Post-Quantum Cryptography) se introdujo en el build 27852 y superiores, esto quiere decir que antes de esta versión, si usted intenta abrir un archivo que utilizan estos algoritmos, Windows simplemente va a tirar un error indicando que el certificado tiene un formato inválido.

En la actualidad, la única forma de tener acceso a esa versión de Windows es mediante el Canary Channel, el cual da acceso a las capacidades mas recientes y experimentales de Windows. Es considerado altamente técnico puesto que muchos de los errores que se pueden encontrar podrían no tener una solución adecuada por parte de Microsoft.

Existen varias maneras de habilitar el Canary Channel de Windows, pero el mas sencillo es habilitarlo en el GUI de Windows Update, haciendo click en la pestaña de “Windows Insider Program”, y escogiendo el radio button de “Canary Channel”

El soporte formal para ML-KEM (Key Encapsulation), ML-DSA y SLH-DSA (Signature algorithms) se introdujo en .NET 10, por lo cual vamos a necesitar bajar e instalar la versión más reciente de .NET 10.

Procedimiento

Vamos a enfocarnos en ML-DSA, y el objetivo principal va a ser cubrir las funcionalidades básicas que ofrece esta clase utilizando el lenguaje C#.

Creando un certificado self-signed

using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;

var dsaAlgorithm = MLDsaAlgorithm.MLDsa65;
var hashAlgorithm = HashAlgorithmName.SHA512;
var subjectName = new X500DistinguishedName($"CN=ML-DSA-Certificate, O=ExampleOrg, C=US");

// Generación de la llave
MLDsa mldsaKey = MLDsa.GenerateKey(dsaAlgorithm);
CertificateRequest certRequest = new CertificateRequest(
    subjectName,
    mldsaKey
);
certRequest.CertificateExtensions.Add(
    new X509BasicConstraintsExtension(true, false, 0, true));
certRequest.CertificateExtensions.Add(
    new X509KeyUsageExtension(X509KeyUsageFlags.KeyCertSign | X509KeyUsageFlags.CrlSign, true));

DateTimeOffset notBefore = DateTimeOffset.Now.AddDays(-1);
DateTimeOffset notAfter = DateTimeOffset.Now.AddYears(1);

// Creación del certificado
X509Certificate2 certificate = certRequest.CreateSelfSigned(notBefore, notAfter);

Firmando con el certificado y validando la firma

// ------------------------------------------------------------------
// Parte 1: Generando la firma
// ------------------------------------------------------------------

const string originalData = "Mensaje que quiero firmar usando la llave ML-DSA";
byte[] dataToSign = Encoding.UTF8.GetBytes(originalData);

// Definir el hash algorithm del certificado (que es diferente al de la llave)
HashAlgorithmName hashAlgorithm = HashAlgorithmName.SHA256;

byte[] signatureContext = Encoding.UTF8.GetBytes("Application-Usage-V1");


// Accesar la llave privada del certificado
MLDsa mldsaPrivateKey = certificate.GetMLDsaPrivateKey();

if (mldsaPrivateKey == null)
{
    Console.WriteLine("\nERROR: No se puede obtener la llave privada del certificado.");
    return;
}

byte[] signature;
try
{
    Console.WriteLine("\n--- Firmando datos con la llave privada ---");

    // Llamando al método que firma los datos
    signature = mldsaPrivateKey.SignData(dataToSign, signatureContext);

    Console.WriteLine($"Firma exitosa, utilizando ({signature.Length} bytes).");
    Console.WriteLine($"Firma (Base64): {Convert.ToBase64String(signature).Substring(0, 32)}..."); // Mostrar un fragmento de la firma

}
catch (CryptographicException ex)
{
    Console.WriteLine($"\nERROR durante firma: {ex.Message}");
    return;
}


// ------------------------------------------------------------------
// Parte 2: Verificando la firma
// ------------------------------------------------------------------

// Cargar la llave pública
MLDsa mldsaPublicKey = certificate.GetMLDsaPublicKey();
if (mldsaPublicKey == null)
{
    Console.WriteLine("\nERROR: No se puede obtener la llave pública del certificado.");
    return;
}

// Verificación
Console.WriteLine("\n--- Validando la firma ---");
bool isValid = mldsaPublicKey.VerifyData(
    dataToSign,
    signature,
    signatureContext
);

if (isValid)
{
    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine("La firma digital es válida!");
}
else
{
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine("La firma digital es inválida!");
}
Console.ResetColor();

// Clean up
mldsaPrivateKey.Dispose();
mldsaPublicKey.Dispose();

Exportando el certificado

// Salvar el certificado (incluyendo la llave privada) en un archivo PFX
string pfxFilePath = "mldsa_certificate.pfx";
string pfxPassword = "MySecurePassword";

// Exportar el certificado en un archivo
byte[] pfxBytes = certificate.Export(X509ContentType.Pfx, pfxPassword);
File.WriteAllBytes(pfxFilePath, pfxBytes);

Console.WriteLine($"\nEl certificado se salvó en: {Path.GetFullPath(pfxFilePath)}");
Console.WriteLine($"Contraseña: {pfxPassword}");

Conclusión

En este momento, el soporte para PQC por parte de Windows se encuentra apenas dando sus primeros pasos, sin embargo las bases han sido sentadas y es adecuado aprender sobre estas tecnologías dada la importancia que van a tomar en la segunda mitad de la década tecnológica de los 20s.

Esta ha sido una de las principales razones por las cuales los proveedores en la nube se han vuelto tan prominentes, porque tienen la capacidad de proveer este tipo de arquitectura sin que uno se tenga que preocupar por los detalles de implementación, aunque esto por lo general trae un alto costo.

Esta configuración se puede implementar usando infraestructura local (on-premise) o en la nube, lo cual provee una gran flexibilidad pero además, posibilita la reducción de costos al estar basada completamente en software libre.

Vamos a similar una red mesh con 5 instancias, vamos a instalar una instancia en 5 namespaces distintos dentro de un mismo cluster de Kubernetes, sin embargo, es importante entender que en un ambiente de producción, se pueden tener estas bases de datos instaladas en diferentes puntos físicos y que no necesariamente tienen que ser el mismo servidor.

Pre-requisitos

Antes de comenzar con la instalación de Microsoft SQL Server 2022 en Kubernetes, es esencial contar con un clúster de Kubernetes funcional. Para ello, te recomendamos seguir los pasos detallados en nuestra: Guía para crear un servidor personal de Kubernetes. Esta guía te proporcionará las instrucciones necesarias para configurar tu entorno de Kubernetes de manera adecuada, asegurando que los siguientes pasos del tutorial se ejecuten sin inconvenientes.

Procedimiento

Vamos a simular 5 nodos distintos utilizando 5 namespaces diferentes en kubernetes. Cada uno de estos nodos va a correr una instancia de PostgreSQL, y cada nodo va a replicar y recibir cambios del resto de los nodos en la red:

• Script que crea 5 namespaces e instala postgresql en cada uno de ellos

    helm repo add bitnami https://charts.bitnami.com/bitnami
    helm repo update
  
    for i in {1..5}
    do
        echo "========= n$i ========="
        helm install pg$i bitnami/postgresql -n n$i --create-namespace \
            --set auth.postgresPassword=postgres \
            --set auth.replicationUsername=active_active \
            --set auth.replicationPassword=active \
            --set architecture=replication \
            --set auth.database=db01 \
            --set primary.service.type=LoadBalancer \
            --set primary.persistence.storageClass=longhorn \
            --set primary.persistence.size=1Gi \
            --set primary.configuration="wal_level=logical
            max_replication_slots=10
            max_wal_senders=10
            max_worker_processes=8
            max_logical_replication_workers=4
            max_sync_workers_per_subscription=2
            listen_addresses='*'"
    done
  

• Crear una tabla y la publicación en cada nodo

    for u in {1..5}
    do
        echo "========= pg$u ========="
        kubectl exec -n n$u pg$u-postgresql-primary-0 -- bash -c "
            PGPASSWORD=postgres psql -U postgres -d db01 -c \"
                drop publication if exists pg$u;
                drop table if exists t1;
                create table t1(
                    id uuid default gen_random_uuid(),
                    comments text default 'pg$u-example',
                    t_stamp timestamptz default now(),
                    PRIMARY KEY (t_stamp,id)
                );
                grant all on all tables in schema public to active_active;
                create publication pg$u for table t1;
            \"
        "
    done
  

• Creando la suscripción en todos los nodos

    for u in {1..5}
    do
        for v in {1..5}
        do
            if [ $u -ne $v ]
            then
                echo "========= pg$u -> pg$v ========="
                kubectl exec -n n$u pg$u-postgresql-primary-0 -- bash -c "
                    PGPASSWORD=postgres psql -U postgres -d db01 -c \"
                    CREATE SUBSCRIPTION pg$v
                        CONNECTION 'host=pg$v-postgresql-primary-hl.n$v.svc.cluster.local port=5432 dbname=db01 user=active_active password=active'
                        PUBLICATION pg$v
                        WITH (origin=none, copy_data=false, slot_name=pg$u);
                    \"
                "
            fi
        done
    done
  

Pruebas

Para verificar que la replicación está funcionando adecuadamente, vamos a crear una nueva fila en la tabla t1 dentro de cada una de las instancias. Luego, vamos a hacer un select en cada una de las 5 instancias y ambas deberíamos de poder ver todas las 5 filas en cada una de ellas.

• Creando una nueva fila en cada una de las 5 instancias. Esto demuestra que es posible escribir en cualquier instancia y que la información va a ser replicada al resto de los nodos:

    for u in {1..5}
    do
        echo "========= insert into pg$u ========="
        kubectl exec -n n$u pg$u-postgresql-primary-0 -- bash -c "
            PGPASSWORD=postgres psql -U postgres -d db01 -c \"
                INSERT INTO t1 (t_stamp) VALUES (default);
            \"
        "
    done
  

• Ahora revisamos los resultados en t1 para cada una de las 5 instancias

    for u in {1..5}
    do
        echo "========= select pg$u ========="
        kubectl exec -n n$u pg$u-postgresql-primary-0 -- bash -c "
            PGPASSWORD=postgres psql -U postgres -d db01 -c \"
                SELECT * FROM t1;
            \"
        "
    done
  

Datos adicionales

La clave para que la replicación mesh funcione en postgreSQL es el parámetro origin=none dentro de la definición de la suscripción; este parámetro es el que evita que se ejecute una replicación infinita entre los nodos.

El parámetro origin controla el origen de los datos que van a ser replicados. Cuando una nueva entrada es creada localmente, el origin es none, pero cuando se replica la información, el origin es el nodo en el que se creó la información, por lo que cuando un suscriptor recibe la nueva fila, esta se guarda localmente, y al ver que el origin es diferente a none, no se replica a otros nodos.

Si usted quisiera entender mejor como se ve la información que está siendo replicada, puede revisar la tabla de suscripciones en uno de los nodos:

kubectl exec -n n1 pg1-postgresql-primary-0 -- bash -c "
    PGPASSWORD=postgres psql -U postgres -d db01 -c \"
        SELECT subname, subenabled, subconninfo, subslotname FROM pg_subscription;
    \"
"

Conclusión

PostgreSQL provee mecanismos robustos para crear bases de datos que son capaces de replicar datos transaccionales a múltiples nodos de manera eficiente y confiable.

Este ejemplo puede ser extendido para poder crear esquemas tipo arbol de navidad, para por ejemplo agregar bases de datos que evitan que los reportes conectados a las bases de datos afecten el rendimiento total del sistema.

Pre-requisitos

• El soporte para ML-DSA fue introducido a partir de OpenSSL 3.5.

• Existen algoritmos PQC para varios propósitos, pero en esta guía nos vamos a enfocar en algoritmos stateless y asimétricos para firmas digitales: ml-dsa-44, ml-dsa-65 y ml-dsa-87 (categorías de seguridad 128/192/256-bit).

• Tome en cuenta que el soporte en la actualidad a nivel de industria para este tipo de certificados sigue siendo limitado. No se recomienda utilizar este tipo de certificados TODAVIA en producción a no ser que sepa MUY BIEN lo que está haciendo.

• Esta vez vamos a utilizar Windows para nuestro tutorial, pero las instrucciones funcionan para cualquier sistema operativo en el que se pueda utilizar openssl 3.5+.

Utilizando la versión correcta de OpenSSL

• Bajar la versión más reciente de OpenSSL en versión ZIP para Windows de aquí:

    https://download.firedaemon.com/FireDaemon-OpenSSL/FireDaemon-OpenSSL-x64-3.6.0.exe
  

• Ejecute el instalador y asegúrese de habilitar la opción de agregar al PATH:

  

• Abra una sesión de DOS/command prompt y asegúrese de tener permisos de lectura/escritura en el directorio de trabajo que decida utilizar

  

Creando un CA

Vamos a enfocarnos en un ejemplo básico que no incluya un RA, el cual es un componente clave cuando se construye una infrastuctura de PKI. Por lo pronto, comenzamos creando el CA:

• Generar una llave privada ML-DSA (escoja ml-dsa-44 / -65 / -87)

    openssl genpkey -algorithm ml-dsa-87 -out ca-priv.pem
  

• Generamos un CA temporal para pruebas utilizando un certificado self-signed con una validez de 10 años:

    openssl req -x509 -new -key ca-priv.pem -subj "/CN=Test CA" -days 3650 -nodes -keyout ca.key -out ca.crt
  

Creación del certificado firmado por el CA

• Generar una llave privada ML-DSA (escoja ml-dsa-44 / -65 / -87)

    openssl genpkey -algorithm ml-dsa-65 -out mldsa65-priv.pem
  

• Extraiga la llave pública

    openssl pkey -in mldsa65-priv.pem -pubout -out mldsa65-pub.pem
  

• Crear un CSR

    openssl req -new -key mldsa65-priv.pem -subj "/CN=example.local" -out mldsa65.csr
  

• Crear un certificado self-signed con una validez de 1 año:

    openssl req -x509 -new -key mldsa65-priv.pem -subj "/CN=example.local" -days 365 -out mldsa65-self.crt
  

• Firmar el CSR con un CA cert+key

    openssl x509 -req -in mldsa65.csr -CA ca.crt -CAkey ca.key -CAcreateserial -days 365 -out mldsa65-by-ca.crt
  

Verificación

• Obtener una versión texto del certificado privado:

    openssl x509 -in mldsa65-by-ca.crt -text -noout
  

  

• Verificar el certificado firmado por el CA:

    openssl verify -CAfile ca.crt mldsa65-by-ca.crt
  

  

Conclusión

El Post-Quantum Cryptography (PQC) es el futuro, Microsoft ya comenzó a soportar librerías de PQC en .NET 10, Chrome Browser desde hace varios años empezó la adopción de PQC, y existen muchos otros ejemplos más de los gigantes de la industria adoptando estas prácticas.

Este laboratorio permite tener acceso a los mismos algoritmos y tecnología criptográfica que los gigantes de la industria están empezando a adoptar alrededor del planeta.

Limitaciones

Para este ejemplo, es importante destacar que no se va a contar con la integración a Active Directory (a pesar de que es posible hacerlo) y tampoco estará disponible el servicio de Microsoft SQL Server Agent.

Pre-requisitos

Antes de comenzar con la instalación de Microsoft SQL Server 2022 en Kubernetes, es esencial contar con un clúster de Kubernetes funcional. Para ello, te recomendamos seguir los pasos detallados en nuestra: Guía para crear un servidor personal de Kubernetes. Esta guía te proporcionará las instrucciones necesarias para configurar tu entorno de Kubernetes de manera adecuada, asegurando que los siguientes pasos del tutorial se ejecuten sin inconvenientes.

Procedimiento

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Namespace
metadata:
  name: mssql
---
apiVersion: v1
kind: Secret
metadata:
  name: mssql-secret
  namespace: mssql
type: Opaque
stringData:
  SA_PASSWORD: "YourStrong!Passw0rd"   # ⚠️ Reemplazar con un password fuerte
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mssql-pvc
  namespace: mssql
spec:
  storageClassName: longhorn
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mssql
  namespace: mssql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mssql
  template:
    metadata:
      labels:
        app: mssql
    spec:
      securityContext:
        fsGroup: 10001
      containers:
      - name: mssql
        image: mcr.microsoft.com/mssql/server:2022-latest
        ports:
        - containerPort: 1433
        env:
        - name: ACCEPT_EULA
          value: "Y"
        - name: SA_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mssql-secret
              key: SA_PASSWORD
        volumeMounts:
        - name: mssql-data
          mountPath: /var/opt/mssql
      volumes:
      - name: mssql-data
        persistentVolumeClaim:
          claimName: mssql-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: mssql
  namespace: mssql
spec:
  type: LoadBalancer
  selector:
    app: mssql
  ports:
  - protocol: TCP
    port: 1433
    targetPort: 1433
EOF

Probando la nueva instancia de Microsoft SQL Server 2022

Empiece por verificar el IP asignado por MetalLB a su instancia:

kubectl get svc mssql -n mssql -o jsonpath='{.status.loadBalancer.ingress[0].ip}'

Utilice este IP en la ventana de conexión del SQL Server Management Studio 21 o superior:

Tome en cuenta que para este ejemplo, el password del usuario “sa” es: YourStrong!Passw0rd

Conclusión

En este artículo vimos cómo instalar Microsoft SQL Server 2022 en Kubernetes, cubriendo la creación del contenedor y el acceso al servicio. Al combinar la robustez de SQL Server con la escalabilidad de Kubernetes, es posible crear entornos de bases de datos modernos, flexibles y fácilmente gestionables.

Es recomendable investigar sobre mejores prácticas de seguridad antes de intentar correr esta instancia en un ambiente de producción.

Nuestros objetivos para esta guía van a ser los siguientes:

• Habilitar una instancia de Kubernetes que utilice pocos recursos pero que no limite el aprendizaje sobre contenedores.

• Lograr gestionar la instancia de Kubernetes utilizando una interfaz gráfica.

• Poder publicar servicios que se puedan accesar externamente utilizando un número de IP.

• Poder almacenar informacion permanentemente, a pesar de la naturaleza efímera de los contenedores.

Entre los objetivos que fueron excluídos para esta guía se encuentran:

• Mejores prácticas de seguridad.

• Arquitectura e implementación para un ambiente de producción.

• Explicación detallada de los componentes de Kubernetes.

• Como instalar el Sistema Operativo Ubuntu 24.04 LTS y operaciones básicas de Linux como elevar los privilegios del comando a ser ejecutado (por ejemplo, utilizando el comando su).

• Configuración de la red.

Pre-requisitos

Es importante que el lector tenga todo esto listo antes de seguir los pasos descritos más adelante:

• Una subred dentro del rango de IPs reservados, con al menos 16 IPs disponibles. Para esta guía, vamos a asumir que la red disponible se encuentra dentro del rango 10.0.0.0/24, pero los servicios que se van a publicar estarán en las IPs que van desde 10.0.0.70 a 10.0.0.99.

• Una máquina física o virtual con al menos 16GB de memoria, 10GB de disco duro y 2 procesadores. Nos vamos a referir a este servidor con el nombre de “host”, y vamos a asumir que utiliza el IP 10.0.0.12 (efectivamente, el IP se encuentra fuera del rango de los IPs libres que vamos a necesitar, pero dentro de la misma subred 10.0.0.0/24).

• El sistema operativo Ubuntu 24.04 LTS va a estar instalado en el host.

Instalando Kubernetes

Vamos a utilizar K3S para faciilar la instalación de Kubernetes, nos enfocaremos en correr todos los servicios en una sola computadora, lo cual está bien para un servidor personal, pero no para un ambiente de producción. Ejecute el siguiente comando para instalar Kubernetes en el host utilizando K3S:

curl -sfL https://get.k3s.io | INSTALL_K3S_CHANNEL=latest K3S_TOKEN=SECRET sh -s - --write-kubeconfig-mode 644 --disable traefik --disable servicelb

El servicio va a durar un par de minutos habilitándose, mientras tanto nos vamos a enfocar en acciones que nos van a hacer más fácil su gestionamiento. Estos comandos van a requerir de un re-inicio de sesión en Linux.

Edite el archivo ~/.bashrc, y agregue la siguiente línea al final:

alias kubectl="k3s kubectl”

Adicionalmente, edite el archivo /etc/environment y agregue la siguiente linea al final del archivo:

KUBECONFIG="/etc/rancher/k3s/k3s.yaml"

En este punto los servicios de Kubernetes deben estar arriba, y puede verificar que todo está corriendo normalmente utilizando el siguiente comando:

kubectl version

Si todo funciona correctamente, el resultado debería verse así:

Adicionalmente, si necesita desinstalar K3S porque quisiera comenzar desde 0, puede utilizar:

/usr/local/bin/k3s-uninstall.sh

Implementando un load balancer para la red

Un servicio de load balancer nos permite tener un IP que envía las solicitudes que este recibe a alguno de los nodos en nuestro cluster de Kubernetes. En nuestro caso solo tenemos un nodo/servidor, pero entender como funciona un load balancer es básico para poder implementar un cluster de múltiples nodos a futuro.

La implementación del load balancer la vamos a hacer utilizando MetalLB. El primer paso es de hecho instalar el servicio de MetalLB en el cluster de Kubernetes utilizando el siguiente comando:

kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.15.2/config/manifests/metallb-native.yaml

Luego, ocupamos indicarle a MetalLB cuales son los IPs que puede utilizar para asignar a los servicios que vamos a instalar en el cluster; como dijimos anteriormente, nuestros IPs van desde 10.0.0.70 a 10.0.0.90. Nota: a Kubernetes le va a tomar un rato levantar todos los contenedores/servicios de MetalLB antes de que este comando funcione.

cat <<EOF | kubectl apply -f -
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: default-pool
  namespace: metallb-system
spec:
  addresses:
  - 10.0.0.70-10.0.0.90
EOF

Finalmente, ocupamos que MetalLB anuncie los IPs a la red, esto se logra con el comando:

cat <<EOF | k3s kubectl apply -f -
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: external-pool
  namespace: metallb-system
spec:
  ipAddressPools:
  - default-pool
EOF

Probando el load balancer

Estamos listos para correr nuestro primer ejemplo “Hello World!”, para ello, vamos a publicar un servicio de nginx (webserver), que nos permita usar nuestro navegador para ver el mensaje “Hello World!”.

kubectl create namespace sandbox
kubectl create deploy nginx-test --image nginx --namespace sandbox
kubectl get pods --all-namespaces
kubectl expose deploy nginx-test --namespace sandbox --port 80 --type LoadBalancer
kubectl get svc --all-namespaces

Una vez que corran esos comandos y los servicios se encuentren arriba, va a poder ver la página navegando a: (Note el uso de http y no https)

http://10.0.0.70

Gestionando Kubernetes usando un dashboard

Kubernetes puede ser gestionado mediante la linea de comandos utilizando el comando kubectl, pero vamos a habilitar una interfaz gráfica para facilitar este proceso. Comenzamos instalando el servicio:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml 

kubectl patch svc kubernetes-dashboard -n kubernetes-dashboard -p '{"spec": {"ports": [{"port": 443,"targetPort": 8443,"name": "https"}],"type": "LoadBalancer"}}'

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard
EOF

cat <<EOF | kubectl apply -f -
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard
EOF

Una vez que todos los contenedores/servicios del Kubernetes dashboard estén corriendo, podrá ingresar al dashboard utilizando la dirección: (Note el uso de https)

https://10.0.0.71

Para poder autenticarse en la pantalla de login, va a necesitar generar un token primero, mediante el comando:

kubectl -n kubernetes-dashboard create token admin-user

Copie y pegue ese comando en la pantalla de login y podrá ingresar al dashboard. Este es un ejemplo de la vista de los pods para todos los namespaces:

Habilitando almacenamiento persistente

El almacenamiento persistente nos permite conservar información aún y cuando un contenedor se mate, reinicie o mueva. Por su naturaleza, los contenedores no conservan los cambios que se les hace, a no ser que la información se guarde dentro de un medio de almacenamiento persistente.

Volviendo a nuestro ejemplo, en este punto hemos habilitado una serie de servicios que no necesitan guardar información persistente, pero cuando se hace necesario hacerlo, vamos a tener que habilitar un servicio llamado persistent storage.

Esta vez, vamos a realizar la instalación utilizando Helm, que es un manejador de paquetes para Kubernetes (Helm es a Kubernetes lo que Aptitude/apt es a Ubuntu). Para ello, vamos a ejecutar:

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

A continuación, vamos a instalar Longhorn, que se caracteriza por proveer una arquitectura hyper-converged.

sudo apt install open-iscsi 

helm repo add longhorn https://charts.longhorn.io
helm repo update
helm install longhorn longhorn/longhorn --create-namespace --namespace longhorn-system
kubectl patch storageclass local-path -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"false"}}}'

Probando el almacenamiento persistente

Vamos a modificar nuestra instancia Hello World en nginx para que se puedan almacenar los archivos del sitio en el sistema de archivos del host. Para ello, empezamos creando un Persistent Volume Claim (PVC):

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nginx-pvc
  namespace: sandbox
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: longhorn
  resources:
    requests:
      storage: 1Gi
EOF

Luego ocupamos modificar la instancia existente de nginx para que haga uso del PVC:

kubectl patch deployment nginx-test -n sandbox --type='json' -p='[{"op": "add", "path": "/spec/template/spec/volumes", "value": [{"name": "nginx-storage", "persistentVolumeClaim": {"claimName": "nginx-pvc"}}]}, {"op": "add", "path": "/spec/template/spec/containers/0/volumeMounts", "value": [{"name": "nginx-storage", "mountPath": "/usr/share/nginx/html"}]}]'

Y finalmente modificamos el contenido del archivo para cambiar el mensaje que muestra el sitio:

kubectl exec $(kubectl get pods -n sandbox -l app=nginx-test -o jsonpath='{.items[0].metadata.name}') -n sandbox -- sh -c 'echo "<h1>Hello from my Longhorn volume!</h1>" > /usr/share/nginx/html/index.html'

En este punto, puede acceder el servicio nuevamente en http://10.0.0.70 y va a notar un nuevo mensaje. No solamente eso, puede matar el pod, y el nuevo pod va a contener el mismo mensaje gracias al almacenamiento persistente.

Conclusión

Logramos construir un cluster de Kubernetes con un load balancer, almacenamiento persistente, dashboard y un sitio de nginx que hace uso de todos esos recursos.

Los ejercicios en esta guía pueden ser utilizados en un futuro dentro de contenedores con múltiples nodos, los cuales son aptos para escenarios que van más allá del simple aprendizaje de la tecnología.

• Reanudar la copia cuando se cae la red o alguno de los servidores falla

• Maximizar el ancho de banda para disminuir el tiempo de copia

• Copiar únicamente archivos que han cambiado

• Asegurarse de que la copia se haga de manera segura

• Recibir notificaciones cuando han ocurrido problemas con el proceso de copia

• Permitir copiar archivos entre diferentes plataformas y sistemas operativos

• Permitir hacer múltiples copias simultáneas, inclusive a lugares físicamente distantes

• Habilitar la copia de archivos a dispositivos tanto en la red empresarial como a servidores en la nube

Pues bien, existe una manera de cumplir con los objetivos listados anteriormente y más, utilizando un programa gratuito llamado Syncthing.

¿Como funciona Syncthing?

Desde el punto de vista tecnológico, Syncthing utiliza el protocolo de comunicación BitTorrent. Sin embargo, esto no significa que cualquiera en el Internet puede ver sus archivos a través de la red Torrent, por el contrario, Syncthing permite que estos archivos sean intercambiados de manera privada, pero manteniendo todas las ventajas tecnológicas que una red peer-to-peer como Torrent puede traer.

La instalación de Syncthing se puede hacer en diferentes dispositivos, desde máquinas físicas o virtuales corriendo Windows, Linux, Mac OS X, etc. hasta dispositivos especializados como un NAS, un teléfono celular y muchos más. Syncthing le permite escoger cuales archivos o folders van a ser compartidos utilizando configuraciones simples o complejas que usted mismo puede especificar en detalle.

Instalando Syncthing en Windows

Los siguientes pasos detallan una guía de instalación básica de Syncthing. Por favor note que este método no es recomendable para ser usado en un servidor de producción, este es simplemente un ejemplo de como poner a correr Syncthing de una forma rápida y simple.

• Baje el archivo instalador con la versión mas reciente de Syncthing: https://github.com/syncthing/syncthing/releases
  Nota: El archivo de instalación para Windows tiene un nombre que comienza con “syncthing-windows-amd64“, seguido por la versión. La extensión del archivo es .zip

• Copie el archivo .zip a todas las computadoras que van a formar parte de la copia de archivos privados.

• Extraiga los archivos del .zip, y ejecute el archivo syncthing.exe en cada computadora

• Se abrirá una pantalla de consola y adicionalmente se abrirá una nueva ventana en su Internet browser apuntando a la página de configuración de Syncthing en: http://127.0.0.1:8384/

Operando Syncthing

Una vez que el servicio está corriendo en los servidores que van a participar en la copia de archivos, es necesario ejecutar dos acciones adicionales: agregar los dispositivos a la red Syncthing y especificar lo que se quiere compartir.

Agregar el dispositivo a la red Syncthing

Desde la página principal de Syncthing:

• Obtenga la identificación de cada dispositivo, esta identificación única es creada por Syncthing y se puede ver haciendo click al hyperlink ubicado dentro de la sección “This Device”, al lado derecho de “Identification”

• 

  El siguiente paso es agregar este primer dispositivo a los demás dispositivos en la red. Esto se logra haciendo click al botón “+ Add Remote Devices“ en los otros dispositivos de la red, e introduciendo el Device ID así como el Device Name. Finalmente haga click en el botón Save para salvar los datos:

  

• De vuelta en el primer servidor, deberá confirmar que desea establecer la conexión":

  

• Una conexión correcta será confirmada por Syncthing en la sección de Remote Devices

  

Especificar lo que se quiere compartir

De vuelta en la página principal:

• Haga click en el botón Add Folder e introduzca los datos solicitados en el formulario

  

• Haga click en el tab Sharing, y especifique el servidor que va a tener acceso a este folder

  

• Una vez completada esta configuración del folder, deberá aceptar el Sharing:

• Finalmente Syncthing mostrará el folder con su estado actual en la pantalla principal:

A partir de este momento, Syncthing se va a encargar de mantener ambos folders sincronizados. Para conocer en detalle otras formas de configurar Syncthing, recomendamos referirse a la documentación oficial.

Ecosistema y futuro de Syncthing

Los líderes técnicos dentro de las empresas conocen bien la importancia de entender no solo cómo funciona una tecnología, sino el ecosistema que la rodea y su visión a futuro.

En el caso de Syncthing, existe la posibilidad de obtener soporte tanto comercialmente, o bajo la sombrilla de código abierto. Es importante entender que una instalación exitosa de este tipo de soluciones requiere de una planeación técnica y de negocio, además es importante preparar planes de contingencia y un proceso de emergencias que describa las acciones a tomar si algo sale mal.

Syncthing tiene a disposición un roadmap abierto, el cual puede ser influenciado, para el desarrollo y futura dirección de las capacidades ofrecidas por la plataforma.

Debido a su amplia adopción en el mercado y robusto soporte por parte de la comunidad de código abierto, Syncthing no presenta riesgos en el corto o mediano plazo.

Conclusión

Syncthing es una solución tecnológica madura, segura y gratuita para resolver el problema de copia de archivos entre computadoras. Puede ser utilizada en una alta diversidad de dispositivos y se adapta a un sinnúmero de casos de uso, los cuales son comunes en las empresas modernas.