Forem: Robert Orozco

DAY 7 - TERRAFORM

Robert Orozco — Tue, 07 Apr 2026 14:22:40 +0000

🗂️ Day 7 of the 30-Day Terraform Challenge — state isolation deep dive. Implemented both Terraform Workspaces and File Layout isolation for multi-environment deployments. Knowing when to use each one is what separates good infrastructure from great infrastructure. #30DayTerraformChallenge #TerraformChallenge #Terraform #IaC #DevOps #AWSUserGroupKenya #EveOps

LAB – PART 1
First, I created three workspaces named dev, staging and production.

Then, I switched to the dev workspace and ran terraform apply. The resource was successfully created.

Next, I switched to the staging workspace and executed terraform plan to validate the configuration.

The (EC2) resource was created successfully with instance type “t3.small”

Now, while working in the staging environment I’ll destroy the resource.

Only the web-staging machine was destroyed.

LAB – PART 2
ISOLATION VIA FILE LAYOUTS
First, I created bootstrap resources. S3 Resource to save the terraform.state of dev and production environment.

Next, I configure the backends files to set the parameter of the S3 name. I pushed terraform plan and terraform apply.

The resource terraform.tfstate was successfully created in S3.

Next, I pushed terraform apply to create the terraform.tfstate file for production environment.

DAY 5: Lab: Benefits of State

Robert Orozco — Mon, 06 Apr 2026 15:18:04 +0000

Today, I performed a cluster web deployment in terraform.

The answer was it.

Take a minute to analyze:

Experiment 1 — Manual state tampering: Manually edit a value in terraform.tfstate

Change instance type

Run terraform plan to see the changes: No changes are needed!

Experiment 2 — State drift: In the AWS Console, manually change a tag on one of your EC2 instances. Run terraform plan without touching your code. Observe how Terraform detects the drift and what it proposes to do about it.

Terraform detech the change:

What is Infrastructure as Code and Why It's Transforming DevOps

Robert Orozco — Thu, 02 Apr 2026 13:22:23 +0000

What IaC is and the problem it solves

Infrastructure as Code (IaC) is the practice of managing and provisioning infrastructure (servers, networks, databases, etc.) using code instead of manual processes.

It solves several key problems:

Manual errors → reduces human mistakes from repetitive tasks
Inconsistency (configuration drift) → ensures all environments are identical
Slow deployments → enables fast, automated provisioning

The difference between declarative and imperative approaches

Imperative approach
You define how to achieve a result step by step.
Example: install packages, configure files, start services manually in sequence.

Declarative approach
You define what the final desired state should be, and the tool figures out how to achieve it.

Why Terraform is worth learning

Terraform is worth learning because:

It allows you to manage infrastructure across multiple cloud providers (AWS, Azure, GCP, etc.)

It uses a simple declarative language, making it easier to understand and maintain

It enables automation and scalability, which are essential in DevOps

It integrates well with modern tools like CI/CD, Docker, and Kubernetes

It is widely adopted and in high demand in the industry

Your personal goals for this 30-day challenge

I want to master the tool and improve my skills.

INSTALAR K8S EN DEBIAN 13

Robert Orozco — Fri, 09 Jan 2026 17:30:56 +0000

¿Qué es Kubernetes?

Es una plataforma de orquestación que permite automatizar el despliegue, scaling y gestión de aplicaciones contenerizadas.

🧩 Paso 1: Preparar el Kernel y la Red

#Deshabilitar Swap
swapoff -a
#Comenta swapoff en /etc/fstab
nano /etc-fstab

#Habilita modulos de kernel
sudo modprobe br_netfilter
sudo modprobe overlay
lsmod | grep br_netfilter
lsmod | grep overlay

#Hacer los cambios persistentes
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

#Configuración de parámetros de red
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

#Verificar las configuraciones
sudo sysctl --system
sysctl net.ipv4.ip_forward

🧩 Paso 2: Instalar los CNI Plugins

wget https://github.com/containernetworking/plugins/releases/download/v1.8.0/cni-plugins-linux-amd64-v1.8.0.tgz

echo "ab3bda535f9d90766cccc90d3dddb5482003dd744d7f22bcf98186bf8eea8be6 cni-plugins-linux-amd64-v1.8.0.tgz" | sha256sum --check

sudo mkdir -p /opt/cni/bin
sudo tar Cxzvf /opt/cni/bin cni-plugins-linux-amd64-v1.8.0.tgz

🧩 Paso 3: Instalar el ContainerRuntime (Puede ser CRI-O o Containerd)

KUBERNETES_VERSION=v1.32
CRIO_VERSION=v1.32

#Instala curl y actualiza
apt-get update
apt-get install -y curl

#Añade los repositorios de Kubernetes
curl -fsSL https://pkgs.k8s.io/core:/stable:/$KUBERNETES_VERSION/deb/Release.key | gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/$KUBERNETES_VERSION/deb/ /" | tee /etc/apt/sources.list.d/kubernetes.list

#Añade los repositorios de CRI-O
curl -fsSL https://download.opensuse.org/repositories/isv:/cri-o:/stable:/$CRIO_VERSION/deb/Release.key | gpg --dearmor -o /etc/apt/keyrings/cri-o-apt-keyring.gpg

echo "deb [signed-by=/etc/apt/keyrings/cri-o-apt-keyring.gpg] https://download.opensuse.org/repositories/isv:/cri-o:/stable:/$CRIO_VERSION/deb/ /" | tee /etc/apt/sources.list.d/cri-o.list

#Instala los paquetes
apt-get update
apt-get install -y cri-o kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
sudo systemctl enable --now kubelet

#Inicia el servicio CRI-O
systemctl start crio.service
systemctl enable crio.service

🧩 Paso 4: Inicializa el Cluster

sudo kubeadm init --pod-network-cidr=10.244.0.0/16

🧩 Paso 5: Copia la configuración de Kubectl para la gestión del cluster.

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

🧩 Paso 6: Instala Flannel

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

🧩 Paso 7: Une el node01 al cluster

Despliegue de una aplicación en AWS usando ECS + ECR

Robert Orozco — Wed, 19 Nov 2025 21:40:16 +0000

En este post te cuento cómo desplegué una aplicación en AWS usando Elastic Container Service (ECS) y Elastic Container Registry (ECR).

👉 La idea es: contenerizamos la app, subimos la imagen, armamos un clúster ECS y la aplicación queda corriendo en ECS (Con EC2)

ARQUITECTURA

🐳 1. Preparar la instancia EC2 para construir la imagen

Primero lanzamos una EC2 con Amazon Linux 2023 para preparar la imagen que luego enviaremos a ECR.

🔧 Instalar Docker y Git

sudo dnf update -y
sudo yum install -y docker
sudo systemctl enable --now docker
sudo systemctl status docker
sudo yum install -y git

📥 Clonar el repositorio y construye la imagen.

Clona la carpeta 4 del repositorio: https://github.com/NotHarshhaa/DevOps-Projects/tree/master/DevOps-Project-04

git clone <URL-del-proyecto>
cd <directorio>
docker build -t hello-world-django-app:version-1 .

Verifica que la imagen existe:

📦 2. Crear el repositorio en ECR

En la consola de AWS:

ECR → Repositories → Create repository

Ponle un nombre como aplicaciones ✔.

Este repo será donde guardaremos nuestras imágenes Docker para que ECS pueda consumirlas.

🔐 3. Rol IAM para permitir que EC2 interactúe con ECR

1️⃣ Crear el rol

IAM → Roles → Create Role → EC2
Agrega la politica:
AmazonEC2ContainerRegistryPowerUser (push + pull)
Nombre sugerido: ec2-ecr-role

2️⃣ Asignar el rol a tu instancia EC2

EC2 → Instance → Actions → Security → Modify IAM role
Selecciona ec2-ecr-role.

*🔑 4. Login en ECR + Push de la imagen
*
En la EC2 define estas variables:

ACCOUNT_ID=$(aws sts get-caller-identity --query "Account" --output text)
AWS_REGION=us-east-2
ECR_URI=${ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com

🔐 Loguearte en ECR

aws ecr get-login-password --region $AWS_REGION \
  | docker login --username AWS --password-stdin $ECR_URI

🏷 Etiquetar la imagen

docker tag hello-world-django-app:version-1 $ECR_URI/aplicaciones:version-1

🚀 Subir la imagen (push)

docker push $ECR_URI/aplicaciones:version-1

¡Imagen lista en ECR! 🐳📦

☁️ 5. Crear el clúster ECS

🔧 Configuración del clúster
Selecciona Fargate e instancias EC2 autoadministradas
Crea un Auto Scaling Group “bajo demanda” (modo prueba: 1 instancia)
Selecciona el rol básico de ECS
Elige dos subredes mínimo (ej: us-east-2a y us-east-2b)
Crea un SG llamado ecs-sg

📑 6. Definición de tarea (Task Definition)

Aquí le decimos a ECS qué contenedor correr, cuánta memoria, puertos, etc.

⚙️ Configuración principal

Nombre: app-task
Infraestructura: EC2
Modo de red: bridge
CPU: 0.5 vCPU
Memoria: 1 GB
Rol de ejecución: el de ECS

📦 Contenedor
Nombre: django-app
Image URI: selecciona la imagen que subiste a ECR 🐳
Puertos: 8000:8000

🎯 7. Crear el servicio ECS

Para que la app quede corriendo de forma continua:

ECS → Cluster → Create Service
Familia de tareas: app-task
Launch type: EC2
Número de tareas: 1

🌐 8. Probar la app en el navegador

Con esta arquitectura se ha desplegada una aplicacion mediante el uso de ECR y ECS para orquestar contenedores.

Como instalar certificados SSL en Cisco C8000V

Robert Orozco — Tue, 03 Jun 2025 17:52:20 +0000

Este procedimiento está basado en la siguiente guía oficial de Webex:
🔗 https://help.webex.com/en-us/article/d68vi1/Site-survivability-for-Webex-Calling#task_T89

1️⃣ Accede al equipo Cisco C8000V:

enable
configure terminal

2️⃣ Genera la clave RSA privada:

crypto key generate rsa general-keys label webex-sgw exportable modulus 2048

3️⃣ Configura el trustpoint:
Reemplaza por el FQDN de tu gateway (por ejemplo: migsbc.ejemplo.com):

crypto pki trustpoint webex-sgw 
 enrollment terminal 
 fqdn <gateway_fqdn> 
 subject-name cn=<gateway_fqdn>
 subject-alt-name <gateway_fqdn>
 revocation-check crl 
 rsakeypair webex-sgw

4️⃣ Genera el CSR (Certificate Signing Request):

crypto pki enroll webex-sgw

Copialo con el siguiente formato:
-----BEGIN CERTIFICATE REQUEST-----
Insert CSR here
-----END CERTIFICATE REQUEST-----

5️⃣ Solicita el certificado SSL:

6️⃣ Une los certificados intermedios y el root:
Concatena en orden correcto los certificados intermedios y el certificado raíz provistos por la CA, tal como se indica:

cat SectigoPublicServerAuthenticationCADVR36.crt SectigoPublicServerAuthenticationRootR46_USERTrust.crt USERTrustRSACertificationAuthority.crt > intermediosv2.crt

7️⃣ Autentica el trustpoint con la cadena de certificados intermediosv2 que se creó en el paso 6.

crypto pki authenticate webex-sgw

8️⃣ Importa el certificado final (emitido por la CA). Copia y pega el contenido del archivo .pem que contiene tu certificado principal:

crypto pki import webex-sgw

9️⃣ Validaciones finales
Una vez instalado el certificado, realiza las siguientes comprobaciones para validar que todo esté correctamente configurado:

✅ Verifica el estado del certificado:

show crypto pki certificates webex-sgw

✅ Verifica las claves RSA generadas:

show crypto key mypubkey rsa

Confirma que exista una clave con la etiqueta webex-sgw.

✅ Verifica la configuración HTTPS del router:

show running-config | include ip http

Confirma que esté habilitado el servicio HTTPS:

ip http secure-server

Si no está habilitado, agrégalo:

configure terminal
ip http secure-server
exit

Automatizar un despliegue en Google Cloud con Terraform

Robert Orozco — Tue, 03 Jun 2025 06:14:31 +0000

Terraform es una poderosa herramienta de infraestructura como código (IaC) que permite crear, modificar y gestionar tu infraestructura de manera segura, repetible y predecible.

TAREA 1️⃣: Usar Terraform en Cloud Shell

Google Cloud Shell ya viene con Terraform instalado. Para verificar la versión, ejecuta:

terraform --version

📁 Ahora, crea un nuevo directorio de trabajo:

Abre el editor integrado de Cloud Shell y crea la siguiente estructura de carpetas y archivos:

🔧 Inicializa Terraform
En el archivo provider.tf define el proveedor de Google Cloud:

Luego ejecuta:

terraform init

✅ Esto descargará los plugins necesarios y preparará tu entorno de trabajo:

TAREA 2️⃣: Configura los archivos .tf

Main.tf
Este archivo define el recurso principal, en este caso, una instancia de máquina virtual en GCP:

resource "google_compute_instance" "vm_instance" {
  name         = "${var.instance_name}"       #Nombre de la instancia
  zone         = "${var.instance_zone}"       #Zona donde se desplegará
  machine_type = "${var.instance_type}"       #Tipo de máquina (e.g. e2-medium)

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"        #Imagen base del disco (Debian 11)
    }
  }

  network_interface {
    network = "${var.instance_network}"       #Red en la que estará la VM
    access_config {
    }
  }
}

Variables.tf
Aquí definimos las variables utilizadas en el módulo de la instancia:

variable "instance_name" {}
variable "instance_zone" {}
variable "instance_type" {
  default = "e2-micro"
  }
variable "instance_network" {}

Mynetwork.tf
Este archivo define tres componentes fundamentales para tu infraestructura:

Una red VPC en modo automático
Una regla de firewall que permite tráfico HTTP, SSH, RDP e ICMP.
Dos máquinas virtuales (instancias) desplegadas en diferentes regiones.

# Crear la red "mynetwork" en modo automático
resource "google_compute_network" "mynetwork" {
  name                    = "mynetwork"
  auto_create_subnetworks = "true"  # Crea subredes automáticamente en todas las regiones
}

# Añadir una regla de firewall para permitir tráfico HTTP, SSH, RDP e ICMP
resource "google_compute_firewall" "mynetwork-allow-http-ssh-rdp-icmp" {
  name    = "mynetwork-allow-http-ssh-rdp-icmp"
  network = google_compute_network.mynetwork.self_link  # Apunta a la red creada

  allow {
    protocol = "tcp"
    ports    = ["22", "80", "3389"]  # SSH (22), HTTP (80), RDP (3389)
  }

  allow {
    protocol = "icmp"  # Permite ping
  }

  source_ranges = ["0.0.0.0/0"]  # Permite tráfico desde cualquier IP
}

# Crear la instancia "mynet-vm-1" en la zona us-west1-a usando un módulo
module "mynet-vm-1" {
  source           = "./instance"
  instance_name    = "mynet-vm-1"
  instance_zone    = "us-west1-a"
  instance_network = google_compute_network.mynetwork.self_link
}

# Crear la instancia "mynet-vm-2" en la zona asia-south1-b usando el mismo módulo
module "mynet-vm-2" {
  source           = "./instance"
  instance_name    = "mynet-vm-2"
  instance_zone    = "asia-south1-b"
  instance_network = google_compute_network.mynetwork.self_link
}

TAREA 3️⃣: Despliegue de infraestructura

terraform plan
terraform apply

El resultado

🎯 Terraform te da el poder de automatizar tu infraestructura desde código, garantizando entornos replicables, consistentes y fáciles de mantener.

Crear una imágen personalizada en Google Cloud

Robert Orozco — Mon, 02 Jun 2025 02:39:23 +0000

Hola 👋 En este blog te mostraré cómo crear una imagen personalizada en Google Cloud que podrás reutilizar para desplegar múltiples instancias de forma rápida y consistente.

1️⃣ Crear una instancia
2️⃣ Configurar los siguientes parámetros:

Nombre: webserver
Región: us-east1
Zona: us-east1-c 3️⃣ Disco de arranque (Boot Disk): configurar la opción "Keep boot disk" para que el disco se mantenga incluso si se elimina la instancia. 4️⃣ Usa una etiqueta de red allow-health-check

5️⃣ Selecciona la red default. En IP externa selecciona none
6️⃣ Conectate por SSH la instancia y ejecuta:
sudo apt-get update sudo apt-get install -y apache2

Comprueba que el disco esté configurado como persistente y que el servicio web esté corriendo en la instancia.

7️⃣ Elimina la instancia. (Tranquilo, el disco no se eliminará gracias a la opción "Keep boot disk")
8️⃣ Ve a Images y crear imágen.
9️⃣ En Source Disk usa el disco webserver para crear la imágen.

🎉 ¡Y eso es todo! Ahora tienes una imagen personalizada que puedes usar como base para tus futuras instancias.

🌍 Cómo configurar un Balanceador de Carga de Aplicaciones con Escalado Automático en Google Cloud

Robert Orozco — Mon, 02 Jun 2025 02:17:36 +0000

Cuando hablamos de alto rendimiento y disponibilidad global, el balanceo de carga de aplicaciones (HTTP/HTTPS) en Google Cloud es una pieza clave. Este tipo de balanceador opera directamente en el borde de la red de Google, es decir, en sus puntos de presencia (POP) distribuidos por todo el mundo.

✅ ¿Qué significa esto?
Que el tráfico de los usuarios entra primero por el POP más cercano geográficamente, y desde ahí es enrutado de manera inteligente a través de la red global de Google hasta el backend más adecuado, considerando la capacidad disponible y la cercanía.

Arquitectura del laboratorio.

TAREA 1️⃣ Crear una regla de firewall para Health Check

Los healthcheck determinan qué instancias de un balanceador de carga de aplicaciones (HTTP) pueden recibir nuevas conexiones. Los Healthcheck dirigidos a las instancias provienen de direcciones en los rangos *130.211.0.0/22 y 35.191.0.0/16 *. Las reglas del firewall deben permitir estas conexiones.

1 Crear regla de firewall.
2 En nombre colocar “fw-allow-health-check”
3 Colocar la etiqueta “allow-health-checks”. En Source IPv4 ranges colocar 130.211.0.0/22 y 35.191.0.0/16. Especificar el protocolo TCP y el puerto 80.

TAREA 2️⃣ Configurar Cloud NAT con Cloud Router

Las instancias no tendrán IPs públicas, en su lugar se configurará el servicio Cloud NAT para permitir que las instancias de VM envíen tráfico saliente solo a través de Cloud NAT y reciban tráfico entrante a través del balanceador de carga.

1 Crear Cloud Nat
2 Nat Type: Publico. Para el Cloud Router seleccionar la red “default” y la región us-east1.
3 Se debe crear el Cloud Router. En nombre colocar: nat-router-us1

TAREA 3️⃣ Crear una imagen personalizada para el Web Server

Usaremos una imagen personalizada para crear instancias consistentes del servidor web.
🔗 Sigue esta guía para crearla:
👉 https://dev.to/robertdev/crear-una-imagen-personalizada-en-google-cloud-cn3

TAREA 4️⃣ Crear una plantilla de instancia y un grupo de instancias. (Instance Template e Instance Groups)

En esta tarea se configuran instance templates y se crean managed instance groups, que son esenciales para construir los backends del balanceador HTTP.

1 Crear una instance template
2 Nombre: mywebserver-template y en location selecciona global.
3 El tipo de máquina E2 "Shared-Core"
4 En boot disk click en cambiar.
5 Selecciona la imágen personalizada que se configuró en la TAREA 3️⃣
6 No asignes una ip pública a la instancia.

Una vez creada la plantilla, crea el grupo de instancias.

1 Crear un Instance Group
2 Usa la plantilla creada en la TAREA 4️⃣

🔐 Cómo configurar una HA CLOUD VPN en Google Cloud paso a paso

Robert Orozco — Sun, 01 Jun 2025 06:46:39 +0000

En este artículo aprenderás a desplegar una VPN de Alta Disponibilidad (HA VPN) en Google Cloud con enrutamiento dinámico mediante BGP. Esta configuración es ideal para escenarios donde se requiere conectividad resiliente entre entornos on-premise simulados y redes VPC.

🎯 Objetivos del laboratorio
Crear dos redes VPC (una para cloud y otra que simula un entorno on-premise).

Configurar puertas de enlace VPN HA en cada red.
Crear túneles IPsec redundantes.
Establecer emparejamientos BGP para enrutamiento dinámico.
Probar conectividad entre ambas redes.

Arquitectura del laboratorio.

*🧱 Paso 1: Crear red VPC y máquinas virtuales
*

gcloud compute networks create vpc-demo --subnet-mode custom

gcloud compute networks subnets create vpc-demo-subnet1 \
  --network vpc-demo --range 10.1.1.0/24 --region us-central1

gcloud compute networks subnets create vpc-demo-subnet2 \
  --network vpc-demo --range 10.2.1.0/24 --region us-east1

gcloud compute firewall-rules create vpc-demo-allow-custom \
  --network vpc-demo --allow tcp:0-65535,udp:0-65535,icmp \
  --source-ranges 10.0.0.0/8

gcloud compute firewall-rules create vpc-demo-allow-ssh-icmp \
  --network vpc-demo --allow tcp:22,icmp

gcloud compute instances create vpc-demo-instance1 \
  --machine-type=e2-medium --zone us-central1-c --subnet vpc-demo-subnet1

gcloud compute instances create vpc-demo-instance2 \
  --machine-type=e2-medium --zone us-east1-b --subnet vpc-demo-subnet2

📸 Instancia creada en la subred vpc-demo-subnet1

📸 Instancia creada en la subred vpc-demo-subnet2

🧪 Paso 2: Crear VPC para entorno on-premise simulado

gcloud compute networks create on-prem --subnet-mode custom

gcloud compute networks subnets create on-prem-subnet1 \
  --network on-prem --range 192.168.1.0/24 --region us-central1

gcloud compute firewall-rules create on-prem-allow-custom \
  --network on-prem --allow tcp:0-65535,udp:0-65535,icmp \
  --source-ranges 192.168.0.0/16

gcloud compute firewall-rules create on-prem-allow-ssh-icmp \
  --network on-prem --allow tcp:22,icmp

gcloud compute instances create on-prem-instance1 \
  --machine-type=e2-medium --zone us-central1-b --subnet on-prem-subnet1

📸 Instancia creada en la subred on-prem-subnet1

🌐 Paso 3: Crear VPN Gateways y Cloud Routers

gcloud compute vpn-gateways create vpc-demo-vpn-gw1 \
  --network vpc-demo --region us-central1

gcloud compute vpn-gateways create on-prem-vpn-gw1 \
  --network on-prem --region us-central1

📸 VPN gateways creados para demo y on-prem.

gcloud compute routers create vpc-demo-router1 \
  --region us-central1 --network vpc-demo --asn 65001

gcloud compute routers create on-prem-router1 \
  --region us-central1 --network on-prem --asn 65002

📸 Cloud Routers creados para demo y on-prem.

🔄 Paso 4: Crear túneles HA VPN (Usa la misma clave compartida [SHARED_SECRET] para todos los túneles.)

# Desde VPC-DEMO
gcloud compute vpn-tunnels create vpc-demo-tunnel0 \
  --peer-gcp-gateway on-prem-vpn-gw1 --region us-central1 \
  --ike-version 2 --shared-secret [SHARED_SECRET] \
  --router vpc-demo-router1 --vpn-gateway vpc-demo-vpn-gw1 --interface 0

gcloud compute vpn-tunnels create vpc-demo-tunnel1 \
  --peer-gcp-gateway on-prem-vpn-gw1 --region us-central1 \
  --ike-version 2 --shared-secret [SHARED_SECRET] \
  --router vpc-demo-router1 --vpn-gateway vpc-demo-vpn-gw1 --interface 1

# Desde ON-PREM
gcloud compute vpn-tunnels create on-prem-tunnel0 \
  --peer-gcp-gateway vpc-demo-vpn-gw1 --region us-central1 \
  --ike-version 2 --shared-secret [SHARED_SECRET] \
  --router on-prem-router1 --vpn-gateway on-prem-vpn-gw1 --interface 0

gcloud compute vpn-tunnels create on-prem-tunnel1 \
  --peer-gcp-gateway vpc-demo-vpn-gw1 --region us-central1 \
  --ike-version 2 --shared-secret [SHARED_SECRET] \
  --router on-prem-router1 --vpn-gateway on-prem-vpn-gw1 --interface 1

📸 Interfaz Virtual de creación de Tuneles VPN.

🔁 Paso 5: Configurar interfaces de túnel y BGP Peers

# Interfaces y Peers para VPC-DEMO
gcloud compute routers add-interface vpc-demo-router1 \
  --interface-name if-tunnel0-to-on-prem \
  --ip-address 169.254.0.1 --mask-length 30 \
  --vpn-tunnel vpc-demo-tunnel0 --region us-central1

gcloud compute routers add-bgp-peer vpc-demo-router1 \
  --peer-name bgp-on-prem-tunnel0 --interface if-tunnel0-to-on-prem \
  --peer-ip-address 169.254.0.2 --peer-asn 65002 --region us-central1

gcloud compute routers add-interface vpc-demo-router1 \
  --interface-name if-tunnel1-to-on-prem \
  --ip-address 169.254.1.1 --mask-length 30 \
  --vpn-tunnel vpc-demo-tunnel1 --region us-central1

gcloud compute routers add-bgp-peer vpc-demo-router1 \
  --peer-name bgp-on-prem-tunnel1 --interface if-tunnel1-to-on-prem \
  --peer-ip-address 169.254.1.2 --peer-asn 65002 --region us-central1

# Interfaces y Peers para ON-PREM
gcloud compute routers add-interface on-prem-router1 \
  --interface-name if-tunnel0-to-vpc-demo \
  --ip-address 169.254.0.2 --mask-length 30 \
  --vpn-tunnel on-prem-tunnel0 --region us-central1

gcloud compute routers add-bgp-peer on-prem-router1 \
  --peer-name bgp-vpc-demo-tunnel0 --interface if-tunnel0-to-vpc-demo \
  --peer-ip-address 169.254.0.1 --peer-asn 65001 --region us-central1

gcloud compute routers add-interface on-prem-router1 \
  --interface-name if-tunnel1-to-vpc-demo \
  --ip-address 169.254.1.2 --mask-length 30 \
  --vpn-tunnel on-prem-tunnel1 --region us-central1

gcloud compute routers add-bgp-peer on-prem-router1 \
  --peer-name bgp-vpc-demo-tunnel1 --interface if-tunnel1-to-vpc-demo \
  --peer-ip-address 169.254.1.1 --peer-asn 65001 --region us-central1

#Reglas de firewall
gcloud compute firewall-rules create vpc-demo-allow-subnets-from-on-prem \
  --network vpc-demo --allow tcp,udp,icmp \
  --source-ranges 192.168.1.0/24

gcloud compute firewall-rules create on-prem-allow-subnets-from-vpc-demo \
  --network on-prem --allow tcp,udp,icmp \
  --source-ranges 10.1.1.0/24,10.2.1.0/24

📸 Sesiones BGP establecidas entre Cloud Routers

La imagen muestra todas las sesiones BGP activas entre los routers vpc-demo-router1 y on-prem-router1, confirmando que los túneles de la VPN HA están operativos y enrutando tráfico dinámicamente mediante BGP.

✅ Paso 6: Verificar conectividad

Una vez configurados los túneles VPN y emparejamientos BGP, es momento de probar la conectividad entre las instancias de ambas VPC.

Primero, accedemos a la instancia que simula el entorno on-premise, ubicada en la zona us-central1-b:

gcloud compute ssh on-prem-instance1 --zone us-central1-b

Desde allí, realizamos una prueba de conectividad hacia una instancia en la subred vpc-demo-subnet1 (en la misma región):

Una respuesta satisfactoria confirma que el túnel y el enrutamiento dinámico están funcionando correctamente dentro de la región.

🌍 Habilitar enrutamiento global para alcanzar otras regiones

Por diseño, los routers de VPN HA son recursos regionales, lo que significa que solo tienen visibilidad de las rutas dentro de su propia región. Si necesitas alcanzar subredes ubicadas en regiones distintas, como en este caso la us-east1, es necesario activar el modo de enrutamiento global en la VPC.

Hagamos prueba de ping para validar la llegada a otra región.

Por el momento no se llega, por lo tanto ejecutamos:

gcloud compute networks update vpc-demo --bgp-routing-mode GLOBAL
📸 Prueba de conectividad entre regiones tras habilitar enrutamiento global

🧩 Conclusión

La implementación de una VPN de Alta Disponibilidad (HA VPN) en Google Cloud, junto con Cloud Router y BGP dinámico, permite establecer una conexión segura, escalable y resiliente entre redes VPC y entornos on-premise o simulados.

A través de este laboratorio, configuramos múltiples túneles redundantes, establecimos sesiones BGP para el intercambio dinámico de rutas y validamos la conectividad entre regiones activando el modo de enrutamiento global.

📊 Explorando tu facturación en Google Cloud con BigQuery (de forma sencilla)

Robert Orozco — Sat, 31 May 2025 23:29:07 +0000

¿Quieres tener visibilidad clara sobre en qué se va tu presupuesto en Google Cloud? Con BigQuery puedes analizar fácilmente los detalles de tu facturación y detectar patrones, gastos excesivos o servicios poco usados.

En este mini laboratorio te muestro cómo importar tu data de facturación a BigQuery y aplicar consultas básicas para entender mejor tu consumo en la nube. 🧠☁️

🚀 Paso 1: Crear el dataset

Primero, ve a BigQuery desde la consola de GCP y crea un nuevo dataset. Es como una carpeta donde vas a guardar tus tablas.

Configuración recomendada:

ID del dataset: billing_dataset
Ubicación: US

📥 Paso 2: Cargar la tabla desde Cloud Storage
Ahora importa el archivo CSV o JSON de facturación que descargaste desde Cloud Billing hacia BigQuery. Para eso:

Dentro del dataset, haz clic en "Crear tabla" y configura el origen y destino.

🔎 Hagamos una consulta para explorar el gasto.

📈 ¿Cuál es el producto con mayor costo total?

SELECT
  service.description AS servicio,
  ROUND(SUM(cost), 2) AS costo_total
FROM
  `billing_dataset.sampleinfotable`
GROUP BY
  servicio
ORDER BY
  costo_total DESC

Así detectas rápidamente qué servicio está consumiendo la mayor parte de tu presupuesto.

✅ Conclusión

BigQuery no es solo para grandes volúmenes de datos; también es una excelente herramienta para analizar tus gastos en la nube. En pocos minutos puedes importar tus datos de facturación y comenzar a tomar decisiones más inteligentes sobre tu infraestructura.

[Boost]

Robert Orozco — Sat, 31 May 2025 23:14:28 +0000