DEV Community: Afu Tse (Chainiz)

Instalación de JFrog Artifactory OSS en Ubuntu 22.04 (Jammy) + PostgreSQL - Guia Completa

Afu Tse (Chainiz) — Fri, 06 Feb 2026 13:58:22 +0000

Tutorial paso a paso para instalar JFrog Artifactory OSS en Ubuntu 22.04 (Jammy) usando PostgreSQL.

⚠️ Nota: Este setup no está pensado para producción. Cambia contraseñas, restringe accesos y revisa backups/SSL antes de usarlo en entornos reales.

Contenido

Requisitos
Arquitectura
0. Preparación de Ubuntu 22.04 (Jammy)
1. Base de datos PostgreSQL
2. Instalar Artifactory OSS
3. Configurar Artifactory OSS para usar PostgreSQL
4. Iniciar Artifactory
5. Abrir puertos (firewall)
6. Entrar a la UI y credenciales por defecto
Comandos útiles
Referencias

Requisitos

VM con Ubuntu 22.04 (Jammy)
Acceso sudo (superusuario)
Conectividad a internet para bajar paquetes
Puertos abiertos en firewall (al menos 8082)

Arquitectura

0. Preparación de Ubuntu 22.04 (Jammy)

Confirmar que estás en Jammy:

lsb_release -a

cat /etc/os-release

Actualizar librerías:

sudo apt update && sudo apt -y upgrade

1. Base de datos PostgreSQL

1.1 Instalar PostgreSQL

sudo apt install -y postgresql postgresql-contrib
sudo systemctl enable --now postgresql
sudo systemctl status postgresql --no-pager

1.2 Crear la base de datos y usuario para Artifactory

sudo -u postgres psql <<'SQL'
CREATE USER artifactory WITH PASSWORD 'ArtifactoryDemo123!';
CREATE DATABASE artifactory OWNER artifactory ENCODING 'UTF8';
GRANT ALL PRIVILEGES ON DATABASE artifactory TO artifactory;
SQL

⚠️ Recomendación: cambia esta contraseña si la VM no es 100% privada.

2. Instalar Artifactory OSS

2.1 Agregar repositorio + key

Agregar el repo OSS (para Jammy):

echo "deb https://releases.jfrog.io/artifactory/artifactory-debs jammy main" | sudo tee -a /etc/apt/sources.list

Agregar la key GPG:

wget -qO - https://releases.jfrog.io/artifactory/api/gpg/key/public | sudo apt-key add -

2.2 Instalar Artifactory OSS (Open Source)

JFrog recomienda tener net-tools como prerequisito:

sudo apt-get update
sudo apt-get install -y net-tools
sudo apt-get install -y jfrog-artifactory-oss

3. Configurar Artifactory OSS para usar PostgreSQL

La configuración principal está en:

JFROG_HOME por defecto: /opt/jfrog
Archivo: /opt/jfrog/artifactory/var/etc/system.yaml

3.1 Detener Artifactory

sudo systemctl stop artifactory

3.2 Editar `system.yaml`

Abrir el archivo system.yaml con editor VIM:

sudo vim /opt/jfrog/artifactory/var/etc/system.yaml

Agregar/ajustar esta sección shared:

shared:
  database:
    type: postgresql
    driver: org.postgresql.Driver
    url: jdbc:postgresql://127.0.0.1:5432/artifactory
    username: artifactory
    password: ArtifactoryDemo123!

4. Iniciar Artifactory

sudo systemctl start artifactory.service
sudo systemctl status artifactory.service --no-pager

Ver logs si hace falta:

sudo journalctl -u artifactory -n 200 --no-pager

5. Abrir puertos (firewall)

Para la UI normalmente se usa 8082 (y a veces 8081 según el setup). Para este caso, abre al menos 8082.

sudo ufw allow 8082/tcp
sudo ufw status

6. Entrar a la UI y credenciales por defecto

Abrir:

http://<TU_IP>:8082/
http://<TU_IP>:8082/ui/
Login directo: http://<TU_IP>:8082/ui/login

Credenciales por defecto:

admin / password

⚠️ Cambia la contraseña apenas puedas.

Fix rápido (OSS): deshabilitar jfconnect (workaround login “stuck”)

Si al iniciar sesión el botón queda inactivo o se “queda pegado” el login (reportado en OSS 7.125.x), aplica este workaround:

Edita:

sudo vim /opt/jfrog/artifactory/var/etc/system.yaml

Agrega esto a nivel raíz (top-level), NO dentro de shared:

jfconnect:
  enabled: false

Reinicia:

sudo systemctl restart artifactory

Prueba de nuevo: http://:8082/ui/ o http://:8082/ui/login

Comandos útiles

Estado del servicio:

sudo systemctl status artifactory --no-pager

Logs recientes:

sudo journalctl -u artifactory -n 200 --no-pager

Reiniciar:

sudo systemctl restart artifactory

Verifica que el puertos está escuchando y en qué interfaz:

sudo ss -lntp | egrep ':8081|:8082'
curl -I http://127.0.0.1:8082/ | head
curl -I http://127.0.0.1:8081/ | head

Referencias

JFrog Platform Installation Documentation: https://jfrog.com/help/r/jfrog-platform-installation-documentation
Install Artifactory on Debian/Ubuntu (APT): https://jfrog.com/help/r/jfrog-installation-setup-documentation/install-artifactory-on-debian
PostgreSQL Documentation: https://www.postgresql.org/docs/

Implementar un sitio web estático en Cloudflare Pages usando Terraform y Wrangler CLI

Afu Tse (Chainiz) — Sun, 25 Jan 2026 22:58:01 +0000

En este tutorial, aprenderá a implementar un sitio web estático en Cloudflare Pages usando Terraform para el aprovisionamiento de infraestructura y Wrangler CLI para la implementación manual.

Este enfoque le permite administrar su proyecto de Cloudflare Pages como Infraestructura como Código (IaC), manteniendo un proceso de implementación simple y flexible.

Qué aprenderás

Al finalizar este tutorial, podrás:

Aprovisionar un proyecto de Cloudflare Pages con Terraform
Implementar un sitio web estático con la CLI de Wrangler
Configurar un dominio personalizado (opcional)
Administrar tu infraestructura de forma limpia y reproducible
Destruir todos los recursos de forma segura cuando ya no sean necesarios

¿Por qué Cloudflare Pages + Terraform?

Cloudflare Pages ofrece una plataforma rápida, global y sin servidor para alojar sitios web estáticos.

Terraform te permite definir y versionar tu infraestructura, lo que garantiza la consistencia y repetibilidad de tus implementaciones.

La combinación de ambas herramientas te ofrece:

Infraestructura como Código
CDN global rápida
Implementación sencilla de sitios estáticos
Gestión sencilla de dominios
Separación clara entre infraestructura y aplicación

Requisitos Previos

Antes de comenzar, asegúrese de tener:

Terraform instalado (versión 1.10.0 o superior)
Cuenta de Cloudflare con acceso a Pages
API Token de Cloudflare con permisos de Cloudflare Pages
Node.js y npm instalados (para Wrangler CLI)

Estructura del Proyecto

cloudflare-tf-staticweb/
└── infrastructure/           # Carpeta con archivos terraform
    ├── main.tf               # Configuración de Terraform
    ├── providers.tf          # Configuración de providers
    ├── variables.tf          # Definición de variables
    ├── cloudflare.tf         # Recursos de Cloudflare Pages
    ├── outputs.tf            # Outputs del proyecto
    ├── terraform.tfvars      # Variables (no versionar)
└── website/                  # Carpeta con el sitio web estático
    └── index.html            # Contiene el HTLM de la página principal
    └── styles.css            # Contiene el CSS de la página principal
    └── script.js             # Contiene el JS de la página principal

Variables

Variable	Descripción	Requerida	Default
`cloudflare_api_token`	API Token de Cloudflare	Sí	-
`cloudflare_account_id`	Account ID de Cloudflare	Sí	-
`project_name`	Nombre del proyecto	No	"my-website"
`custom_domain`	Dominio personalizado	No	""

Configuración Inicial

1. Crear el Proyecto

# Crear la estructura de carpetas
mkdir cloudflare-tf-staticweb
cd cloudflare-tf-staticweb

2. Configurar la Infraestructura

En la carpeta "cloudflare-tf-staticweb"

# Crear la carpeta de la infraestructura
mkdir infrastructure

# Accede a la carpeta infraestructura
cd infrastructure

# Crear el archivo "main.tf"
cat <<EOF > main.tf
terraform {
  required_version = ">= 1.10.0"

  required_providers {
    cloudflare = {
      source  = "cloudflare/cloudflare"
      version = "~> 4.0"
    }
  }
}
EOF

# Crear el archivo "provider.tf"
cat <<EOF > provider.tf
provider "cloudflare" {
  api_token = var.cloudflare_api_token
}
EOF

# Crear el archivo "variables.tf"
cat <<EOF > variables.tf
variable "cloudflare_api_token" {
  description = "The API token for Cloudflare account"
  type        = string
  sensitive   = true
}

variable "cloudflare_account_id" {
  description = "Cloudflare Account ID (visible on dashboard)"
  type        = string
}

variable "project_name" {
  description = "Project name in Cloudflare Pages"
  type        = string
  default     = "my-website"
}

variable "custom_domain" {
  description = "Custom domain (optional, leave blank if not used)"
  type        = string
  default     = ""
}
EOF

# Crear el archivo "outputs.tf"
cat <<EOF > outputs.tf
output "pages_project_url" {
  description = "Full URL of the Cloudflare Pages project"
  value       = "https://${cloudflare_pages_project.website.subdomain}"
}

output "pages_project_subdomain" {
  description = "Subdomain assigned by Cloudflare Pages"
  value       = cloudflare_pages_project.website.subdomain
}

output "project_id" {
  description = "Cloudflare project ID"
  value       = cloudflare_pages_project.website.id
}

output "project_name" {
  description = "Project Name"
  value       = cloudflare_pages_project.website.name
}

output "custom_domain_url" {
  description = "Custom domain URL (if configured)"
  value       = var.custom_domain != "" ? "https://${var.custom_domain}" : "Not configured"
}
EOF

# Crear el archivo "cloudflare.tf"
cat <<EOF > cloudflare.tf
resource "cloudflare_pages_project" "website" {
  account_id        = var.cloudflare_account_id
  name              = var.project_name
  production_branch = "main"

  build_config {
    build_command   = ""        # No build required for static HTML
    destination_dir = "website" # Folder containing index.html
    root_dir        = ""        # Repository root
  }

  # Environment variables (if needed in the future)
  deployment_configs {
    production {
      environment_variables = {
        ENVIRONMENT = "production"
      }
    }

    preview {
      environment_variables = {
        ENVIRONMENT = "preview"
      }
    }
  }

}

# Custom domain (optional)
resource "cloudflare_pages_domain" "custom_domain" {
  count        = var.custom_domain != "" ? 1 : 0
  account_id   = var.cloudflare_account_id
  project_name = cloudflare_pages_project.website.name
  domain       = var.custom_domain
}
EOF

3. Configurar la pagina web

En la carpeta "cloudflare-tf-staticweb"

# Crear la carpeta del sitio web
mkdir website

# Accede a la del sitio web
cd website

# Crear el archivo "index.html"
cat > index.html << 'EOF'
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Simple Web App</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <div class="container">
        <h1 id="greeting">Hello, World!</h1>
        <input type="text" id="nameInput" placeholder="Enter your name">
        <button id="updateBtn">Update Greeting</button>
    </div>
    <script src="script.js"></script>
</body>
</html>
EOF

# Crear el archivo "styles.css"
cat > styles.css << 'EOF'
* {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

body {
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    background: linear-gradient(135deg, #6a11cb 0%, #2575fc 100%);
    min-height: 100vh;
    display: flex;
    justify-content: center;
    align-items: center;
}

.container {
    background: white;
    padding: 2rem;
    border-radius: 10px;
    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
    text-align: center;
    max-width: 400px;
    width: 90%;
}

h1 {
    color: #333;
    margin-bottom: 1.5rem;
    font-size: 2rem;
}

input {
    padding: 0.8rem;
    width: 100%;
    margin-bottom: 1rem;
    border: 2px solid #ddd;
    border-radius: 5px;
    font-size: 1rem;
}

input:focus {
    outline: none;
    border-color: #2575fc;
}

button {
    background: #2575fc;
    color: white;
    border: none;
    padding: 0.8rem 1.5rem;
    border-radius: 5px;
    cursor: pointer;
    font-size: 1rem;
    transition: background 0.3s;
}

button:hover {
    background: #1a68e8;
}
EOF

# Crear el archivo "script.js"
cat > script.js << 'EOF'
// Get DOM elements
const greetingElement = document.getElementById('greeting');
const nameInput = document.getElementById('nameInput');
const updateButton = document.getElementById('updateBtn');

// Update greeting when button is clicked
updateButton.addEventListener('click', () => {
    const name = nameInput.value.trim();

    if (name) {
        greetingElement.textContent = `Hello, ${name}!`;
        nameInput.value = ''; // Clear input
    } else {
        greetingElement.textContent = 'Please enter your name!';
        setTimeout(() => {
            greetingElement.textContent = 'Hello, World!';
        }, 2000);
    }
});

// Also update on Enter key press
nameInput.addEventListener('keypress', (e) => {
    if (e.key === 'Enter') {
        updateButton.click();
    }
});
EOF

4. Obtener tu Account ID en Cloudflare

Ve al Cloudflare Dashboard → Account Home
Click en los 3 puntos la lado del "Account Name"
Click en "Copy account ID"

5. Crear API Token en Cloudflare

Ve a Cloudflare Dashboard → Manage Account → Account API Tokens
Click en "Create Token" → "Create Custom Token"

Configura los permisos necesarios:

Token name: Terraform Cloudflare Pages

Permissions:
├── Account
│   ├── Cloudflare Pages → Edit
│   └── Account Settings → Read
└── Zone (opcional, solo si usas dominio personalizado)
    └── DNS → Edit

Zone Resources:
└── Include → All zones from an account → Your_Account

Click en "Continue to summary" → "Create Token"
Copia el token inmediatamente (solo se muestra una vez)

6. Actualizar Configuración

Crear el archivos de variables y asignar los valores

cloudflare_account_id obtenido del paso 4
cloudflare_api_token obtenido del paso 5

# Crear el archivo "terraform.tfvars"
cat <<EOF > terraform.tfvars
# Cloudflare Account ID
cloudflare_account_id = "your-account-id-here"


# Cloudflare API Token
cloudflare_api_token = "your-token"

# Project name
project_name = "my-website"

# Custom domain (optional, leave blank if not used)
custom_domain = ""
EOF

Uso

Crear la Infraestructura con Terraform

Accede a la carpeta infraestructura

cd infrastructure

Inicializar Terraform

terraform init

Validar la configuración

terraform validate
terraform fmt

Planificar cambios

terraform plan

Aplicar cambios

terraform apply -auto-approve

Esto creará el proyecto de Cloudflare Pages, pero aún no habrá contenido desplegado.

Ver outputs

terraform output

Desplegar el Sitio Web con Wrangler

Una vez que Terraform haya creado el proyecto, despliega tu sitio:

1. Instalar Wrangler (solo la primera vez)

npm install -g wrangler

2. Autenticar con Cloudflare

wrangler login

Esto abrirá un navegador para que autorices Wrangler.

3. Desplegar el sitio

Desde la raíz del proyecto

wrangler pages deploy website --project-name=my-website

Reemplaza my-website con el valor de tu variable project_name.

4. Verificar el despliegue

Visita la URL mostrada en el output de Terraform o en el resultado del comando deploy:

terraform output pages_project_url

pages_project_url = "https://my-website-xxx.pages.dev"

Despliegues Futuros

Para actualizar tu sitio después de hacer cambios:

Edita tus archivos en website/
Despliega de nuevo

wrangler pages deploy website --project-name=my-website

Reemplaza my-website con el valor de tu variable project_name.

Dominio Personalizado

Para agregar un dominio personalizado:

Actualiza terraform.tfvars:
```
custom_domain = "www.tudominio.com"
```
Asegúrate de que el dominio esté en Cloudflare
Aplica los cambios
```
terraform apply
```

Destruir Recursos

terraform destroy -auto-approve

Recursos Adicionales

Valkey vs Redis – Explicación simple y practica

Afu Tse (Chainiz) — Thu, 08 Jan 2026 21:59:36 +0000

🔑 ¿Qué es Valkey?

Valkey es un fork open-source de Redis, creado en 2024, totalmente compatible, creado tras el cambio de licencia de Redis para mantener una alternativa 100% open source y respaldado por la Linux Foundation.

Surge como respuesta al cambio de licencia de Redis (Redis ≥ 7.4), que dejó de ser open source bajo los estándares de la OSI.

👉 Objetivo de Valkey

Mantener un Redis 100% open source
Compatibilidad total con Redis (comandos, protocolo, clientes)
Gobernanza comunitaria y neutral
Sin vendor lock-in

En la práctica:

Valkey es Redis, pero con licencia abierta y desarrollo comunitario.

🧠 ¿Para qué sirve Valkey?

Exactamente los mismos casos de uso que Redis:

Cache in-memory
Session store
Pub/Sub
Rate limiting
Distributed locks
Streams
Leaderboards
Replication
Persistence (RDB / AOF)
Redis Cluster

⚖️ Valkey vs Redis (comparación rápida)

Característica	Valkey	Redis (≥ 7.4)
Licencia	✅ Open Source (BSD/Apache-style)	❌ RSAL / SSPL
Gobernanza	Linux Foundation	Redis Inc
Compatibilidad	100% Redis	Nativa
Uso comercial	✅ Libre	⚠️ Restricciones
Vendor lock-in	❌ Bajo	⚠️ Mayor
Cloud friendly	✅ Sí	⚠️ Limitado
Soporte K8s	✅ Excelente	✅

🧾 La licencia: el punto clave

Redis hoy

Licencia RSAL / SSPL
No considerada open source por la OSI
Restricciones para SaaS y cloud providers

Valkey

Open source real
Uso comercial sin restricciones
Ideal para empresas, educación y gobiernos

Por eso AWS, Google, Oracle y otros proveedores apoyan Valkey.

🧪 Demo 1 – Valkey local con Docker

docker run -d --name valkey -p 6379:6379 valkey/valkey:latest

Prueba rápida:

redis-cli ping
# PONG

redis-cli set demo "hola valkey"
redis-cli get demo

🧪 Demo 2 – Pub/Sub

Terminal A:

redis-cli subscribe events

Terminal B:

redis-cli publish events "mensaje desde valkey"

Terminal A:

☸️ Demo 3 – Valkey en Kubernetes

Crear el archivo "valkey.yaml"

apiVersion: v1
kind: Namespace
metadata:
  name: demo
---
apiVersion: v1
kind: Service
metadata:
  name: valkey
  namespace: demo
  labels:
    app: valkey
spec:
  # Headless Service required by StatefulSet
  clusterIP: None
  selector:
    app: valkey
  ports:
    - name: redis
      port: 6379
      targetPort: 6379
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: valkey
  namespace: demo
spec:
  serviceName: valkey
  replicas: 1
  selector:
    matchLabels:
      app: valkey
  template:
    metadata:
      labels:
        app: valkey
    spec:
      containers:
        - name: valkey
          image: valkey/valkey:latest
          ports:
            - name: redis
              containerPort: 6379
          volumeMounts:
            - name: data
              mountPath: /data
          readinessProbe:
            tcpSocket:
              port: 6379
            initialDelaySeconds: 5
            periodSeconds: 5
          livenessProbe:
            tcpSocket:
              port: 6379
            initialDelaySeconds: 15
            periodSeconds: 10
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
        accessModes:
          - ReadWriteOnce
        resources:
          requests:
            storage: 1Gi

Desplegar:

kubectl apply -f valkey.yaml

Acceso desde un pod:

kubectl run -it --rm vcli -n demo --image=redis:7 -- bash

Ejecuta el ping para validar conexion

redis-cli -h valkey.demo.svc.cluster.local ping
PONG

Código fuente : k8s-valkey-demo

🔄 ¿Tengo que cambiar código si vengo de Redis?

👉 No.

Mismos comandos
Mismo protocolo RESP
Mismos clientes (redis-cli, node-redis, ioredis, etc.)

Solo cambia la imagen:

image: valkey/valkey

🚀 Conclusión

Si estás construyendo:

Kubernetes
SaaS
Plataformas cloud
Proyectos open source

👉 Valkey es la opción recomendada hoy.

Develop Kubernetes Services Locally (Yes, Really) with Telepresence

Afu Tse (Chainiz) — Wed, 07 Jan 2026 19:19:26 +0000

🚀 What is Telepresence?

Telepresenceis a development tool that lets you connect your local machine directly to a Kubernetes cluster — as if your app were running inside the cluster, even though it’s actually running on your laptop.

🔥 Build, run, and debug Kubernetes services locally, without rebuilding Docker images or redeploying on every change.

🧩 What do developers use Telepresence for?

Telepresence shines in day-to-day Kubernetes development:

✅ Local development against a real cluster
• Your application runs locally
• But it consumes real cluster resources:
• Services
• ConfigMaps
• Secrets
• Internal APIs

No mocks. No fakes. Just real infrastructure.

✅ Intercepting Service traffic
• Telepresence can intercept traffic destined for a Kubernetes Service
• That traffic is transparently redirected to your local app

From the cluster’s point of view, nothing changes.

✅ Fast, comfortable debugging
• Use local logs
• Attach debuggers (VS Code, IntelliJ, etc.)
• Hot reload
• Breakpoints

🙌 All without modifying or risking remote or production environments.

😖 The problem Telepresence solves

❌ Traditional Kubernetes workflow

Every tiny change usually means:

Modify code
docker build
docker push
kubectl apply
Wait for rollout
Test
Repeat 😵‍💫

That’s minutes per iteration — and it kills productivity.

✅ With Telepresence

The workflow becomes:

Change code locally
Save
Test instantly

⏱️ Feedback in seconds, not minutes.

⚙️ How does Telepresence work?

High-level flow:
• Connects to your Kubernetes cluster
• Deploys a Traffic Manager (proxy)
• Intercepts traffic for a Service
• Forwards that traffic to your local machine

From Kubernetes’ perspective:

👉 Your app still exists in the cluster — it just happens to live on your local machine.

🧪 Simple example

Without Telepresence

echo Service → Pod in Kubernetes

With Telepresence

echo Service → your laptop (localhost:9000)

Everything else stays the same:
• Databases
• Other microservices
• Secrets

🔗 Source code: github

🌟 Why you should care

• ⚡ Much faster development cycles
• 🧪 Real debugging against real infrastructure
• 🛡️ Lower risk (no touching prod clusters)
• 🧩 Perfect fit for Kubernetes & microservices

If you work with Kubernetes daily, Telepresence can seriously change how fast — and how comfortably — you build software.

🔗 References

Ejecuta tus servicios de Kubernetes desde tu local con Telepresence

Afu Tse (Chainiz) — Wed, 07 Jan 2026 18:51:56 +0000

¿Qué es Telepresence?

Telepresence es una herramienta de desarrollo que te permite conectar tu computadora local a un clúster de Kubernetes como si tu aplicación local estuviera corriendo dentro del cluster.

En pocas palabras:
🔥 Te deja desarrollar y depurar servicios de Kubernetes sin construir imágenes Docker ni hacer deploy cada vez.

¿Para qué se usa Telepresence?

Se usa principalmente para:

✅ Desarrollo local contra Kubernetes real

Tu app corre localmente
Pero consume Services, ConfigMaps, Secrets y APIs reales del cluster

✅ Interceptar tráfico de un Service

Redirige el tráfico que iba a un Service del cluster
Hacia tu aplicación local

✅ Debugging rápido

Puedes usar logs locales
Debuggers (VS Code, IntelliJ)
Hot reload
Breakpoints

🙌 Todo sin tocar el cluster remoto y/o productivo.

¿Por qué Telepresence es de gran ayuda?

Porque soluciona dolores reales del desarrollo con Kubernetes.

❌ Sin Telepresence (El problema tradicional)

Cada cambio implica:

Cambiar código
docker build
docker push
kubectl apply
Esperar el rollout
Probar
Repetir 😵‍💫

Esto puede tomar minutos por cambio.

✅ Con Telepresence

El flujo se vuelve:

Cambias código local
Guardas
Pruebas inmediatamente

⏱️ Cambios en segundos, no minutos.

¿Cómo funciona Telepresence?

Flujo:

Se conecta al cluster
Inserta un proxy (Traffic Manager)
Intercepta el tráfico de un Service
Lo envía a tu máquina

Desde Kubernetes:
👉 Parece que tu app sigue ahí, pero en realidad está en tu computadora.

Ejemplo

Sin Telepresence:

echo Service → Pod en Kubernetes

Con Telepresence:

echo Service → tu laptop (localhost:9000)

Y el resto del cluster se mantiene igual

Databases
Otros microservicios
Secrets

🔗 Codigo fuente: minikube-telepresence-demo

Beneficios

Desarrollo muchísimo más rápido
Debug real contra infraestructura real
Menor riesgo (no tocas ambientes remotos y/o productivos)
Ideal para Kubernetes + microservicios

Ejecuta Qwen3 + Ollama + Open WebUI en Docker: Tu propio AI Chat local 🧠

Afu Tse (Chainiz) — Fri, 02 Jan 2026 22:15:41 +0000

¿Quieres montar tu propio entorno de IA local con un modelo potente sin pagar por la nube?

Con el repositorio qwen3-container puedes hacerlo fácilmente usando Docker Compose, Ollama y Open WebUI 👇

🔗 código fuente

🔥 En este post te explico qué es, cómo funciona y por qué es útil este proyecto.

🧠 ¿Qué es Qwen3?

Qwen3 es la última generación de modelos de lenguaje grande (LLM) de Alibaba Cloud — disponible en múltiples tamaños y con capacidades impresionantes de generación de texto, razonamiento y tareas complejas.

🧰 ¿Qué hace este repositorio?

El proyecto qwen3-container ofrece un stack listo para producción local que combina:

🧠 Ollama — runtime local para LLMs, con Qwen3 precargado
🌐 Open WebUI — interfaz web tipo chat para interactuar con el modelo
🐳 Docker + Docker Compose — para levantar todo con un solo comando

Esto te permite tener un chat local basado en Qwen3 sin depender de APIs externas ni costos por tokens.

🛠️ ¿Cómo funciona el stack?

El proyecto define dos servicios principales:

📌 ollama-qwen3
Ejecuta el modelo Qwen3 dentro de Ollama y expone una API REST en localhost:11434.
📌 open-webui
Proporciona una interfaz de chat en localhost:3000 desde el navegador, donde puedes conversar con Qwen3 sin programar nada.

📦 Instalación rápida

Clona el repositorio

git clone https://github.com/r3xakead0/qwen3-container.git
cd qwen3-container

Configura tu .env (puedes basarte en .env.example)

# Genera un secreto seguro
openssl rand -hex 32

Levanta los contenedores

docker compose up -d

Acceder
- 📡 API: http://localhost:11434
- 🧠 UI chat: http://localhost:3000

💡 ¿Por qué usar esto?

✅ Privacidad y control: tus datos nunca salen de tu máquina
✅ Sin dependencia de la nube: ni tokens ni facturación
✅ Desarrollo rápido: ideal para prototipos, PoCs o herramientas internas
✅ Personalización: puedes enchufar el API de Ollama a tus propias apps

Este stack es ideal si estás trabajando con soluciones de IA local o quieres explorar modelos open-weight como Qwen3 sin pagar por servicios externos.

🔗 Articulo de referencia

🧩 Recomendaciones

👉 Cambia el valor de WEBUI_SECRET_KEY por un secreto largo y seguro.
👉 Una vez inicializado, deshabilita el registro de nuevos usuarios para proteger tu instancia.

🐧 Comandos de procesamiento de texto en Linux: guía práctica

Afu Tse (Chainiz) — Mon, 29 Dec 2025 05:00:00 +0000

Este post explica de forma didáctica y con ejemplos reales los comandos más usados para procesamiento de texto en Linux:

grep
awk
sed
sort
uniq

Ideal para logs, DevOps, SysAdmin y entrevistas técnicas.

1️⃣ grep – Buscar texto

Buscar errores en un log

grep "ERROR" app.log

Buscar sin distinguir mayúsculas

grep -i "error" app.log

Contar coincidencias

grep -c "ERROR" app.log

Mostrar número de línea

grep -n "Exception" app.log

2️⃣ awk – Trabajar con columnas

Mostrar primera columna

awk '{print $1}' archivo.txt

Ver usuarios conectados

who | awk '{print $1}'

Logs Nginx: IP y URL con error 404

awk '$9 == 404 {print $1, $7}' access.log

Sumar valores (ej. tráfico total)

awk '{sum += $10} END {print sum}' access.log

3️⃣ sed – Editar texto

Reemplazar texto

sed 's/http/https/' archivo.txt

Reemplazo global

sed 's/http/https/g' archivo.txt

Eliminar líneas vacías

sed '/^$/d' archivo.txt

Cambiar configuración directamente

sed -i 's/DEBUG=false/DEBUG=true/' app.conf

4️⃣ sort – Ordenar datos

Ordenar alfabéticamente

sort usuarios.txt

Ordenar números

sort -n numeros.txt

Ordenar por columna

sort -k 2 archivo.txt

Ordenar tamaños reales

ls -lh | sort -k 5 -h

5️⃣ uniq – Eliminar duplicados

⚠️ uniq funciona correctamente solo si los datos están ordenados.

Eliminar duplicados

sort nombres.txt | uniq

Contar repeticiones

sort nombres.txt | uniq -c

Mostrar solo duplicados

sort nombres.txt | uniq -d

🔥 Casos reales combinados

IPs que más requests hacen

awk '{print $1}' access.log | sort | uniq -c | sort -nr | head

URLs con más errores 404

awk '$9 == 404 {print $7}' access.log | sort | uniq -c | sort -nr

Errores más frecuentes

grep "ERROR" app.log | awk '{print $5}' | sort | uniq -c | sort -nr

🧠 Resumen rápido

Comando	Uso principal
grep	Buscar texto
awk	Procesar columnas
sed	Editar texto
sort	Ordenar
uniq	Quitar duplicados

📌 Tip DevOps: estos comandos son fundamentales para analizar logs de Docker, Kubernetes, Nginx, AWS, GCP y Azure.

¡Guárdalo, practícalo y úsalo en entrevistas! 🚀

Reemplacé Docker por Podman para ejecutar LLMs locales (Ollama + DeepSeek)

Afu Tse (Chainiz) — Sun, 28 Dec 2025 17:31:53 +0000

Durante mucho tiempo, mis experimentos locales con IA siguieron el camino habitual:

"Docker, docker-compose, descargar un modelo, levantar una UI y listo."

Pero en algún punto empecé a querer algo más limpio:

Contenedores rootless (sin raíz)
Mejor alineación con Linux de nivel enterprise
Sin depender de un daemon de Docker corriendo en segundo plano

Ahí fue cuando decidí reconstruir mi stack local de LLMs usando Podman.

Este post documenta el resultado:

"Ollama + Open WebUI + DeepSeek R1 ejecutándose localmente con Podman Compose"

¿Por qué Podman?

Si trabajas en cloud o platform engineering, seguramente ya viste esta tendencia:

Podman no usa daemon
Corre rootless por defecto
Se integra muy bien con systemd
Cada vez es más estándar en distribuciones Linux enterprise

Para mí, el objetivo era simple:
ejecutar LLMs locales de la misma forma en que ejecutaría servicios en producción.

El stack

Esto es lo que terminé usando:

Ollama → runtime y API de modelos
Open WebUI → interfaz tipo chat
DeepSeek R1 (1.5B) → liviano pero sorprendentemente capaz
Podman Compose → orquestación
Volúmenes de Podman → persistencia de datos

Todos los contenedores corren dentro de un solo Podman Pod, lo que significa: una red compartida, comunicación por localhost y cero magia rara de DNS.

Arquitectura

El archivo Compose

El corazón de este setup es el podman-compose.yml:

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama-deepseek
    ports:
      - "11434:11434"
    environment:
      - OLLAMA_HOST=0.0.0.0:11434
    volumes:
      - ollama-data:/root/.ollama:Z
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "ollama", "list"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  open-webui:
    image: ghcr.io/open-webui/open-webui:latest
    container_name: open-webui
    depends_on:
      - ollama
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY:-secret-key-change-me-in-production}
      - ENABLE_SIGNUP=${ENABLE_SIGNUP:-true}
    volumes:
      - open-webui-data:/app/backend/data:Z
    restart: unless-stopped

  model-loader:
    image: ollama/ollama:latest
    container_name: model-loader
    depends_on:
      - ollama
    environment:
      - OLLAMA_HOST=http://ollama:11434
    entrypoint: ["ollama"]
    command: ["pull", "deepseek-r1:1.5b"]
    restart: on-failure

volumes:
  ollama-data:
    driver: local
  open-webui-data:
    driver: local

Codigo fuente

Un detalle pequeño pero importante:
no uso sh -c para el model loader, ya que la imagen de ollama no garantiza un shell, así que llamo al binario directamente.

Ejecución

podman compose up -d

Primer acceso:

Abres http://localhost:3000
Creas el usuario admin inicial (comportamiento esperado)
Empiezas a chatear

Puedes validar Ollama directamente:

curl http://localhost:11434

Qué me gusta de este setup

Después de usarlo un tiempo, hay varias cosas que destacan:

No hay daemon de Docker corriendo
Todo funciona en modo rootless
Separación clara entre runtime, UI y datos
Fácil de convertir en servicios systemd más adelante (Quadlet)

Y lo más importante:
"Esto se siente como infraestructura, no como un demo".

Notas de seguridad (Importante)

Si vas a exponer esto más allá de localhost:

Cambia WEBUI_SECRET_KEY
Desactiva registros públicos después de crear el primer usuario
Considera un reverse proxy

Que sea local no significa que deba ser inseguro.

Conclusión

Ejecutar LLMs localmente no tiene por qué ser desordenado.
Con Podman + Ollama obtienes un setup que se siente:

Limpio
Reproducible
cercano a producción

Si ya usas Podman en tus workloads, este stack encaja perfecto.

Running DeepSeek R1 + Ollama + Open WebUI with Podman Compose

Afu Tse (Chainiz) — Sun, 28 Dec 2025 17:07:16 +0000

If you want to run local LLMs with a clean, containerized setup without Docker, this guide shows how to deploy DeepSeek R1 + Ollama + Open WebUI using Podman Compose.

This setup is ideal for:

Local AI experimentation
Developers who prefer rootless containers
Teams standardizing on Podman instead of Docker

Why use Podman?

Using Podman is recommended because it is more secure and better aligned with Kubernetes: it runs containers rootless by default, does not rely on a daemon, reduces the attack surface, and fits better in enterprise and CI/CD environments. In addition, it is Docker-compatible at the command level, officially supported by Red Hat, and ideal for Linux servers and production, especially when security and compliance are a priority.

Architecture Overview

The stack runs inside a single Podman Pod, meaning all containers share the same network namespace.

Ollama → model runtime & API
Open WebUI → chat-style web interface
Model Loader → one-shot container to pull the model
Volumes → persistent storage for models and app data

Requirements

Podman
Podman Compose (podman compose or podman-compose)
Free ports:
- 11434 (Ollama API)
- 3000 (Open WebUI)

On SELinux-enabled systems, volumes are mounted using :Z to avoid permission issues.

podman-compose.yml

Here is the core compose file powering the stack:

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama-deepseek
    ports:
      - "11434:11434"
    environment:
      - OLLAMA_HOST=0.0.0.0:11434
    volumes:
      - ollama-data:/root/.ollama:Z
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "ollama", "list"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  open-webui:
    image: ghcr.io/open-webui/open-webui:latest
    container_name: open-webui
    depends_on:
      - ollama
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY:-secret-key-change-me-in-production}
      - ENABLE_SIGNUP=${ENABLE_SIGNUP:-true}
    volumes:
      - open-webui-data:/app/backend/data:Z
    restart: unless-stopped

  model-loader:
    image: ollama/ollama:latest
    container_name: model-loader
    depends_on:
      - ollama
    environment:
      - OLLAMA_HOST=http://ollama:11434
    entrypoint: ["ollama"]
    command: ["pull", "deepseek-r1:1.5b"]
    restart: on-failure

volumes:
  ollama-data:
    driver: local
  open-webui-data:
    driver: local

source code

Configuration

Create a .env file:

WEBUI_SECRET_KEY=change-me-to-a-long-random-secret
ENABLE_SIGNUP=true

Generate a secure secret:

openssl rand -hex 32

Run the Stack

podman compose -f podman-compose.yml up -d

Check status:

podman ps
podman compose -f podman-compose.yml ps

Access:

Open WebUI → http://localhost:3000
Ollama API → http://localhost:11434

On first access, Open WebUI will prompt you to create the initial admin user (expected behavior).

Validation

Verify Ollama:

curl http://localhost:11434

Expected output:

Ollama is running

List models:

curl http://localhost:11434/api/tags

If the model is missing, pull it manually:

podman exec -it ollama-deepseek ollama pull deepseek-r1:1.5b

Stop & Teardown

Stop containers:

podman compose stop

Remove containers (keep data):

podman compose stop

Full cleanup (⚠️ deletes models and users):

podman compose down -v

Security Notes

Always change WEBUI_SECRET_KEY
After creating the first admin user, disable public signups:

ENABLE_SIGNUP=false

Then recreate:

podman compose up -d --force-recreate

Final Thoughts

Running LLMs locally doesn’t have to be messy.
With Podman + Ollama, you get a setup that feels:

clean
reproducible
and production-adjacent

If you’re already using Podman for your workloads, this stack fits right

TF_IN_AUTOMATION le dice a Terraform: No hay humanos aquí

Afu Tse (Chainiz) — Tue, 16 Dec 2025 16:19:18 +0000

¿Qué es TF_IN_AUTOMATION?

Para entender, TF_IN_AUTOMATION es una variable de entorno que Terraform usa para saber si se está ejecutando en un entorno automatizado, como:

CI/CD (GitHub Actions, GitLab CI, Azure DevOps, Jenkins)
Pipelines corporativos
Scripts no interactivos

export TF_IN_AUTOMATION=true

o en un pipeline:

env:
  TF_IN_AUTOMATION: "true"

¿Para qué sirve realmente?

Cuando TF_IN_AUTOMATION=true, Terraform cambia su comportamiento para ser más amigable con la automatización.

1. Menos salida “humana”, más salida “máquina”

Terraform:

Reduce mensajes decorativos
Evita prompts innecesarios
Da logs más predecibles

Ideal para logs de pipelines.

2. Desactiva mensajes interactivos

Terraform asume que no hay una persona sentada frente a la consola.

Ejemplo:

No te va a sugerir comandos
No muestra mensajes tipo “Next steps”

Esto evita que un pipeline:

Se quede colgado esperando input
Genere ruido en los logs

3. Comportamiento esperado en CI/CD

Terraform no falla ni pregunta cosas inesperadas.

Ojo: Esto NO reemplaza

terraform apply -auto-approve

Ejemplos:

GitHub Actions

- name: Terraform Apply
  env:
    TF_IN_AUTOMATION: "true"
  run: |
    terraform init
    terraform plan
    terraform apply -auto-approve

Azure DevOps

variables:
  TF_IN_AUTOMATION: "true"

steps:
- script: |
    terraform init
    terraform plan
    terraform apply -auto-approve
  displayName: Terraform Apply

¿Qué NO hace TF_IN_AUTOMATION?

Esto es importante:
❌ No cambia el plan
❌ No evita errores
❌ No mejora performance
❌ No maneja state
❌ No reemplaza -input=false

Si quieres full non-interactive, normalmente usas:

terraform plan -input=false
terraform apply -auto-approve -input=false

Buenas prácticas

✅ Siempre setearlo en CI/CD
✅ No usarlo en local (no aporta nada)
✅ Combinarlo con:

-input=false
-auto-approve
Backends remotos (S3 + DynamoDB, GCS, Azure RM)
Variables vía TF_VAR_*

Conclusión

TF_IN_AUTOMATION le dice a Terraform:
“No hay humanos aquí, compórtate como una herramienta de automatización”

Notes WebApp - Complete Guide with Cloud Functions, Firestore, and Cloud Storage

Afu Tse (Chainiz) — Sun, 30 Nov 2025 17:10:16 +0000

This project implements a simple Notes WebApp using Google Cloud (GCP) serverless services: Firestore, Cloud Functions, and a static frontend hosted on Cloud Storage.

Code Souce: gcp-notes-app-serverless

🧱 General Architecture

1. NoSQL database:
Firestore in Native mode, collection notes.

2. Serverless backend:
Cloud Functions (Python) exposing a mini REST API:

POST /notes - create note
GET /notes - list notes
GET /notes/{id} - get note detail
PUT /notes/{id} - update note
DELETE /notes/{id} - delete note

3. Frontend:
Web page (HTML/CSS/JS) hosted as a static site in Cloud Storage.

🔧 Step 0: Prerequisites

gcloud auth login
gcloud config set project <PROJECT_ID>

🎯 Step 1: Environment variables

export PROJECT_ID="<PROJECT_ID>"
export REGION="us-central1"
export BUCKET_NAME="${PROJECT_ID}-notas-web"
export FUNCTION_NAME="notes_api"

📦 Step 2: Enable APIs

gcloud services enable \
  firestore.googleapis.com \
  cloudfunctions.googleapis.com \
  storage.googleapis.com

🗄️ Step 3: Create Firestore (Native Mode)

gcloud firestore databases create \
  --location=$REGION \
  --type=firestore-native

🧠 Step 4: Backend Code (Cloud Function)

In Cloud Shell

mkdir notes-backend
cd notes-backend

Create the file main.py

import json
import datetime
from google.cloud import firestore

db = firestore.Client()
NOTES_COLLECTION = "notes"

def _get_cors_headers():
    return {
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS",
        "Access-Control-Allow-Headers": "Content-Type",
    }

def _note_to_dict(doc):
    data = doc.to_dict()
    data["id"] = doc.id
    return data

def notes_api(request):
    # CORS
    if request.method == "OPTIONS":
        return ("", 204, _get_cors_headers())

    headers = _get_cors_headers()
    method = request.method

    path = request.path or "/"
    segments = [seg for seg in path.split("/") if seg]

    is_collection = False
    note_id = None

    if len(segments) == 0:
        is_collection = True              # "/"
    elif len(segments) == 1 and segments[0] == "notes":
        is_collection = True              # "/notes"
    elif len(segments) == 2 and segments[0] == "notes":
        note_id = segments[1]             # "/notes/{id}"
    else:
        return (json.dumps({"error": "Not found"}), 404, headers)

    try:
        # GET list or detail
        if method == "GET":
            if is_collection:
                docs = (
                    db.collection(NOTES_COLLECTION)
                    .order_by("created_at", direction=firestore.Query.DESCENDING)
                    .stream()
                )
                notes = [_note_to_dict(d) for d in docs]
                return (json.dumps(notes), 200, headers)
            else:
                doc = db.collection(NOTES_COLLECTION).document(note_id).get()
                if not doc.exists:
                    return (json.dumps({"error": "Note not found"}), 404, headers)
                return (json.dumps(_note_to_dict(doc)), 200, headers)

        # POST create
        if method == "POST" and is_collection:
            payload = request.get_json(silent=True)
            if not payload or "title" not in payload:
                return (json.dumps({"error": "Invalid JSON"}), 400, headers)

            now = datetime.datetime.utcnow().isoformat() + "Z"

            doc_ref = db.collection(NOTES_COLLECTION).document()
            doc_ref.set({
                "title": payload["title"],
                "detail": payload.get("detail", ""),
                "created_at": now,
                "updated_at": now
            })

            return (json.dumps(_note_to_dict(doc_ref.get())), 201, headers)

        # PUT update
        if method in ("PUT", "PATCH") and note_id:
            payload = request.get_json(silent=True)
            if not payload:
                return (json.dumps({"error": "Invalid JSON"}), 400, headers)

            doc_ref = db.collection(NOTES_COLLECTION).document(note_id)
            if not doc_ref.get().exists:
                return (json.dumps({"error": "Note not found"}), 404, headers)

            updates = {
                "updated_at": datetime.datetime.utcnow().isoformat() + "Z"
            }
            if "title" in payload:
                updates["title"] = payload["title"]
            if "detail" in payload:
                updates["detail"] = payload["detail"]

            doc_ref.update(updates)
            return (json.dumps(_note_to_dict(doc_ref.get())), 200, headers)

        # DELETE remove
        if method == "DELETE" and note_id:
            doc_ref = db.collection(NOTES_COLLECTION).document(note_id)
            if not doc_ref.get().exists:
                return (json.dumps({"error": "Note not found"}), 404, headers)
            doc_ref.delete()
            return (json.dumps({"message": "Note deleted"}), 200, headers)

        return (json.dumps({"error": "Method not allowed"}), 405, headers)

    except Exception as e:
        return (json.dumps({"error": str(e)}), 500, headers)

Includes functionality: create, list, edit, delete notes + CORS.

Create the file requirements.txt

google-cloud-firestore==2.16.0

☁️ Step 5: Deploy Cloud Function

gcloud functions deploy $FUNCTION_NAME \
  --gen2 \
  --runtime=python311 \
  --region=$REGION \
  --source=. \
  --entry-point=notes_api \
  --trigger-http \
  --allow-unauthenticated

Get and store the URL:

export FUNCTION_URL="$(gcloud functions describe $FUNCTION_NAME \
  --region=$REGION \
  --format='value(serviceConfig.uri)')"

echo "FUNCTION_URL = $FUNCTION_URL"

Get and store the service account used by the function:

export SA_EMAIL="$(gcloud functions describe $FUNCTION_NAME \
  --gen2 \
  --region=$REGION \
  --format='value(serviceConfig.serviceAccountEmail)')"

echo "SA_EMAIL = $SA_EMAIL"

Grant Firestore permissions to that service account

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SA_EMAIL" \
  --role="roles/datastore.user"

🧪 Step 6: Test the API

Create note

curl -X POST "$FUNCTION_URL/notes" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "First note",
    "detail": "Hello Firestore"
  }'

List notes

curl "$FUNCTION_URL/notes"

Get note

curl "$FUNCTION_URL/notes/{id}"

Edit note

curl -X PUT "$FUNCTION_URL/notes/kISGMWGfsazN6CIfxqV2" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "First note",
    "detail": "Hello Firestore + Cloud Functions"
  }'

Delete note

curl -X DELETE "$FUNCTION_URL/notes/{id}" \
  -H "Content-Type: application/json"

🧠 Step 7: Frontend Code (HTML + CSS + JS in Cloud Storage)

In Cloud Shell

mkdir notes-frontend
cd notes-frontend

Create the file index.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <title>Notes WebApp</title>
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <link rel="stylesheet" href="styles.css" />
</head>
<body>
  <h1>📒 My Notes</h1>

  <section class="form-section">
    <h2 id="form-title">Create note</h2>
    <form id="note-form">
      <!-- Hidden field for ID when editing -->
      <input type="hidden" id="note-id" />

      <label for="note-title">
        Title:
        <input type="text" id="note-title" required />
      </label>

      <label for="note-detail">
        Detail:
        <textarea id="note-detail" rows="4"></textarea>
      </label>

      <div class="buttons">
        <button type="submit" id="save-btn">Save</button>
        <button type="button" id="cancel-btn">Cancel</button>
      </div>
    </form>
  </section>

  <section class="list-section">
    <h2>List of notes</h2>
    <table id="notes-table">
      <thead>
        <tr>
          <th>Title</th>
          <th>Created</th>
          <th>Actions</th>
        </tr>
      </thead>
      <tbody id="notes-tbody">
        <!-- Dynamic rows -->
      </tbody>
    </table>
  </section>

  <footer>
    <small>Note System with Firestore + Cloud Functions + Cloud Storage</small>
  </footer>

  <script src="app.js"></script>
</body>
</html>

Create the file styles.css

/* General layout */
body {
  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
  max-width: 900px;
  margin: 0 auto;
  padding: 20px;
  background: #f9fafb;
  color: #0f172a;
}

h1 {
  text-align: center;
  margin-bottom: 20px;
}

/* Secciones */
section {
  background: #ffffff;
  padding: 15px 20px;
  margin-bottom: 20px;
  border-radius: 8px;
  box-shadow: 0 1px 3px rgba(15, 23, 42, 0.1);
}

.form-section h2,
.list-section h2 {
  margin-top: 0;
}

/* Formulario */
label {
  display: block;
  margin-bottom: 10px;
  font-size: 0.95rem;
}

input[type="text"],
textarea {
  width: 100%;
  padding: 8px;
  margin-top: 4px;
  border-radius: 4px;
  border: 1px solid #cbd5e1;
  box-sizing: border-box;
  font-size: 0.95rem;
}

textarea {
  resize: vertical;
}

.buttons {
  margin-top: 10px;
}

/* Buttons */
button {
  padding: 8px 14px;
  margin-right: 8px;
  border-radius: 6px;
  border: none;
  cursor: pointer;
  font-size: 0.9rem;
}

#save-btn {
  background-color: #2563eb;
  color: white;
}

#save-btn:hover {
  background-color: #1d4ed8;
}

#cancel-btn {
  background-color: #e5e7eb;
}

#cancel-btn:hover {
  background-color: #d1d5db;
}

/* Table */
table {
  width: 100%;
  border-collapse: collapse;
  margin-top: 10px;
  font-size: 0.9rem;
}

th,
td {
  border-bottom: 1px solid #e5e7eb;
  padding: 8px;
  text-align: left;
}

th {
  background-color: #f1f5f9;
  font-weight: 600;
}

tr:nth-child(even) {
  background-color: #f9fafb;
}

/* Botones de acción */
.action-btn {
  margin-right: 6px;
  padding: 4px 10px;
  border-radius: 4px;
  border: none;
  cursor: pointer;
  font-size: 0.8rem;
}

.edit-btn {
  background-color: #22c55e;
  color: #fff;
}

.edit-btn:hover {
  background-color: #16a34a;
}

.delete-btn {
  background-color: #ef4444;
  color: #fff;
}

.delete-btn:hover {
  background-color: #dc2626;
}

/* Footer */
footer {
  text-align: center;
  color: #6b7280;
  font-size: 0.8rem;
  margin-top: 10px;
}

/* Responsive */
@media (max-width: 600px) {
  body {
    padding: 10px;
  }

  table,
  thead,
  tbody,
  th,
  td,
  tr {
    display: block;
  }

  thead {
    display: none;
  }

  tr {
    margin-bottom: 10px;
    border: 1px solid #e5e7eb;
    border-radius: 6px;
    padding: 8px;
    background: #ffffff;
  }

  td {
    border: none;
    display: flex;
    justify-content: space-between;
    padding: 4px 0;
  }

  td::before {
    content: attr(data-label);
    font-weight: 600;
    margin-right: 8px;
    color: #6b7280;
  }
}

Create the file app.js

👉 Replace API_BASE_URL with your Cloud Function URL.

// Base URL of the Cloud Function
const API_BASE_URL = "https://notes-api-cinsoje5sq-uc.a.run.app";

const form = document.getElementById("note-form");
const noteIdInput = document.getElementById("note-id");
const titleInput = document.getElementById("note-title");
const detailInput = document.getElementById("note-detail");
const cancelBtn = document.getElementById("cancel-btn");
const formTitle = document.getElementById("form-title");
const notesTbody = document.getElementById("notes-tbody");

async function fetchNotes() {
  const res = await fetch(`${API_BASE_URL}/notes`);
  if (!res.ok) {
    console.error("Error fetching notes", res.status);
    return;
  }
  const notes = await res.json();
  renderNotes(notes);
}

function renderNotes(notes) {
  notesTbody.innerHTML = "";
  notes.forEach((note) => {
    const tr = document.createElement("tr");

    const tdTitle = document.createElement("td");
    tdTitle.textContent = note.title;

    const tdCreated = document.createElement("td");
    tdCreated.textContent = note.created_at
      ? new Date(note.created_at).toLocaleString()
      : "";

    const tdActions = document.createElement("td");

    const editBtn = document.createElement("button");
    editBtn.textContent = "Edit";
    editBtn.className = "action-btn edit-btn";
    editBtn.onclick = () => loadNoteForEdit(note);

    const deleteBtn = document.createElement("button");
    deleteBtn.textContent = "Delete";
    deleteBtn.className = "action-btn delete-btn";
    deleteBtn.onclick = () => deleteNote(note.id);

    tdActions.appendChild(editBtn);
    tdActions.appendChild(deleteBtn);

    tr.appendChild(tdTitle);
    tr.appendChild(tdCreated);
    tr.appendChild(tdActions);

    notesTbody.appendChild(tr);
  });
}

function resetForm() {
  noteIdInput.value = "";
  titleInput.value = "";
  detailInput.value = "";
  formTitle.textContent = "Create note";
}

function loadNoteForEdit(note) {
  noteIdInput.value = note.id;
  titleInput.value = note.title;
  detailInput.value = note.detail || "";
  formTitle.textContent = "Edit note";
}

async function saveNote(event) {
  event.preventDefault();

  const id = noteIdInput.value.trim();
  const payload = {
    title: titleInput.value.trim(),
    detail: detailInput.value.trim(),
  };

  if (!payload.title) {
    alert("The title is required");
    return;
  }

  let url = `${API_BASE_URL}/notes`;
  let method = "POST";

  if (id) {
    url = `${API_BASE_URL}/notes/${id}`;
    method = "PUT";
  }

  const res = await fetch(url, {
    method,
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });

  if (!res.ok) {
    const error = await res.json().catch(() => ({}));
    console.error("Error saving note:", error);
    alert("Error saving the note");
    return;
  }

  resetForm();
  fetchNotes();
}

async function deleteNote(id) {
  if (!confirm("Delete this note?")) return;

  const res = await fetch(`${API_BASE_URL}/notes/${id}`, {
    method: "DELETE",
  });

  if (!res.ok) {
    console.error("Error deleting note");
    alert("Error deleting the note");
    return;
  }

  fetchNotes();
}

form.addEventListener("submit", saveNote);
cancelBtn.addEventListener("click", resetForm);

fetchNotes();

🌐 Step 8: Create the website with Cloud Storage

Create bucket:

gsutil mb -l $REGION gs://$BUCKET_NAME

Configure static site:

gsutil web set -m index.html -e index.html gs://$BUCKET_NAME

Allow public access:

gsutil iam ch allUsers:objectViewer gs://$BUCKET_NAME

📤 Step 9: Upload the frontend

gsutil cp index.html styles.css app.js gs://$BUCKET_NAME

🌍 Step 10: Site URL

http://storage.googleapis.com/<BUCKET_NAME>/index.html

🧹 Step 11: Cleanup (optional)

gcloud functions delete $FUNCTION_NAME --region=$REGION --quiet
gsutil rm -r gs://$BUCKET_NAME

🚀 ECS Express Mode: From an image to an HTTPS endpoint in a single step

Afu Tse (Chainiz) — Sun, 30 Nov 2025 16:46:49 +0000

📘 Introduction

When we work with containers, we usually need to configure a lot of
things before we can publish an application: networks, load balancers,
permissions, security, certificates, logs... and that can be
overwhelming for someone just starting out.

To make this process much simpler, AWS released ECS Express Mode, a
new way to deploy containerized applications without having to worry
about all that complicated infrastructure. In this article I explain
what it is, how it works, and why it can be very useful if you're
learning AWS.

🌟 What is ECS Express Mode?

It's a fast way to deploy a containerized application using Amazon ECS.
The idea is simple: you just upload your image to ECR (or use one you
already have), and ECS Express Mode takes care of the rest.

The result?

In just a few clicks or commands, you'll have a running service with
HTTPS, load balancing, monitoring, and autoscaling ready to use.

🧩 What does it automatically create?

ECS Express Mode configures infrastructure for you that normally takes
quite a long time:

✔️ An Application Load Balancer (ALB)
So your application can receive HTTPS traffic securely.
The certificate is also configured automatically.

✔️ CloudWatch Logs
Your application will send logs from the very first minute, no extra
configuration required.

✔️ IAM Roles
It creates the necessary permissions so your tasks can pull the image,
send logs, or access secrets.

✔️ VPC, subnets, and security
If you don't have a network created, AWS places your service inside a
new VPC already configured.

✔️ Autoscaling
Your service can increase or decrease tasks without you having to
configure advanced rules.

🎯 What do you need to configure yourself?

Very little. Just:

The container image
Service port (if not using the standard one)
Any environment variables or secrets (if needed)
Optionally, CPU and memory

Everything else can remain automatic.

🔧 Can it be customized?

Yes. If you already have experience, you can modify:

Existing VPC and subnets
Security group
Log group name
Container startup command
Health checks
Resource limits
Scaling configuration

But if you're just starting out, it's best to leave everything in
default mode.

🧠 Why is this so useful?

Because it lets you focus on what matters: your application.

Learning cloud often means dealing with networks, permissions, security,
certificates... and ECS Express Mode reduces that initial complexity a
lot.
It's ideal if you are:

Learning containers
Practicing deployments on AWS
Creating a project for university
Building an MVP or prototype
Preparing for cloud certifications

You can focus on the workflow without getting lost in advanced details.

📌 Important considerations

Although very practical, keep in mind:

The ALB has a cost; if you create several services, each one may generate its own load balancer.
If you need a complex architecture, Express Mode might fall short.
It's perfect for getting started, but large projects may require more advanced ECS configuration.

🚀 Conclusion

ECS Express Mode is an amazing tool for deploying containerized
applications quickly, easily, and securely---especially if you're
learning AWS. It saves you from having to build all the initial
infrastructure and allows you to focus on development.

If you want to understand how cloud services work without getting
tangled in too many technical details, this is an excellent option.

📚 References

"Announcing Amazon ECS Express Mode"

🌐 Spanish

“ECS Express Mode: de una imagen a un endpoint HTTPS en un solo paso"

DEV Community: Afu Tse (Chainiz)

Instalación de JFrog Artifactory OSS en Ubuntu 22.04 (Jammy) + PostgreSQL - Guia Completa

Contenido

Requisitos

Arquitectura

0. Preparación de Ubuntu 22.04 (Jammy)

1. Base de datos PostgreSQL

1.1 Instalar PostgreSQL

1.2 Crear la base de datos y usuario para Artifactory

2. Instalar Artifactory OSS

2.1 Agregar repositorio + key

2.2 Instalar Artifactory OSS (Open Source)

3. Configurar Artifactory OSS para usar PostgreSQL

3.1 Detener Artifactory

3.2 Editar system.yaml

4. Iniciar Artifactory

5. Abrir puertos (firewall)

6. Entrar a la UI y credenciales por defecto

Fix rápido (OSS): deshabilitar jfconnect (workaround login “stuck”)

Comandos útiles

Referencias

Implementar un sitio web estático en Cloudflare Pages usando Terraform y Wrangler CLI

Qué aprenderás

¿Por qué Cloudflare Pages + Terraform?

Requisitos Previos

Estructura del Proyecto

Variables

Configuración Inicial

1. Crear el Proyecto

2. Configurar la Infraestructura

3. Configurar la pagina web

4. Obtener tu Account ID en Cloudflare

5. Crear API Token en Cloudflare

6. Actualizar Configuración

Uso

Crear la Infraestructura con Terraform

Accede a la carpeta infraestructura

Inicializar Terraform

Validar la configuración

Planificar cambios

Aplicar cambios

Ver outputs

Desplegar el Sitio Web con Wrangler

1. Instalar Wrangler (solo la primera vez)

2. Autenticar con Cloudflare

3. Desplegar el sitio

4. Verificar el despliegue

Despliegues Futuros

Dominio Personalizado

Destruir Recursos

Recursos Adicionales

Valkey vs Redis – Explicación simple y practica

🔑 ¿Qué es Valkey?

🧠 ¿Para qué sirve Valkey?

⚖️ Valkey vs Redis (comparación rápida)

🧾 La licencia: el punto clave

Redis hoy

Valkey

🧪 Demo 1 – Valkey local con Docker

🧪 Demo 2 – Pub/Sub

☸️ Demo 3 – Valkey en Kubernetes

🔄 ¿Tengo que cambiar código si vengo de Redis?

🚀 Conclusión

Develop Kubernetes Services Locally (Yes, Really) with Telepresence

🚀 What is Telepresence?

🧩 What do developers use Telepresence for?

😖 The problem Telepresence solves

⚙️ How does Telepresence work?

🧪 Simple example

🌟 Why you should care

🔗 References

Ejecuta tus servicios de Kubernetes desde tu local con Telepresence

¿Qué es Telepresence?

¿Para qué se usa Telepresence?

¿Por qué Telepresence es de gran ayuda?

¿Cómo funciona Telepresence?

Ejemplo

Beneficios

Ejecuta Qwen3 + Ollama + Open WebUI en Docker: Tu propio AI Chat local 🧠

🧠 ¿Qué es Qwen3?

3.2 Editar `system.yaml`