But how do you start without getting lost in complexity—or costs? This article explores infrastructure fundamentals and the strategic path to becoming a skilled Cloud Engineer.

1. What is GCP and why does it matter?

GCP is a suite of public cloud services sharing the same global infrastructure Google uses for its billion-user products, such as YouTube and Search.

For developers, it offers low-latency networking and military-grade security. The best part for beginners is the entry options to learn without immediate costs:

• Free Credits: Google typically offers a starting credit (often $300) for new users to explore any service.

• Student Programs: Through Google Cloud Skills Boost, students can often access labs and credits via partner institutions.

• Free Tier: Certain resources, like specific Compute Engine instances, are "free tier" (free within monthly usage limits).

⚠️ Pro Tip: Free Tier terms and credit amounts can change without notice. Always set up Budget Alerts in the GCP Billing console. The cloud is elastic—if you misconfigure a service, it will scale, and so will your credit card bill.

2. The Pillars of Cloud Engineering: Layer 4 vs. Layer 7 (OSI Model)

A cloud engineer must master network traffic. When we talk about "Layers," we are referring to the OSI Model (Open Systems Interconnection), a global standard that divides network communication into 7 levels. In GCP, understanding the top layers is vital:

• Layer 4 (Transport): Focuses on raw speed. The L4 load balancer routes packets based on network data like IP addresses and ports (TCP/UDP). It is ideal for applications where performance is critical and inspecting the message content isn't necessary.

• Layer 7 (Application): The "brain" of the network. It understands the content of the message (HTTP/S), such as URLs, cookies, and headers. This allows for "content-based routing"—directing /video traffic to one group of servers and /payments to another, optimizing both cost and user experience.

3. Becoming an Elite Cloud Engineer

The barrier to entry is lowering, but the demand for quality is rising. To stand out:

• Hands-on Experience: Don't just follow manuals. Understand the logic behind automation scripts, such as using $(hostname) variables to identify instances in real-time.

• Certifications: The Associate Cloud Engineer (ACE) exam is the gold standard for beginners, proving you can handle the console, IAM permissions, and the gcloud CLI.

• Architectural Resilience: Learn about MIGs (Managed Instance Groups). The cloud's true power lies in Self-healing and Auto-scaling systems—infrastructure that fixes itself and grows on demand.

Conclusion

Mastering GCP is a journey of continuous practice. Before launching your first major project, explore the credits and Free Tier, but keep a close eye on your billing dashboard. Automation and network intelligence (OSI Model) are your tools; financial responsibility is what keeps your project viable.

Mas como começar sem se perder na complexidade — ou nos custos? Neste artigo, exploramos os fundamentos da infraestrutura e o caminho para se tornar um engenheiro qualificado.

1. O que é o GCP e por que ele é relevante?

O GCP é um ecossistema de serviços de nuvem pública que compartilha a mesma infraestrutura global usada pelo Google para sustentar o YouTube e o seu motor de busca.

Para empresas e desenvolvedores, isso significa acesso a uma rede de baixa latência e segurança de ponta. No entanto, o grande atrativo para quem está começando são as opções de entrada:

• Créditos para Novos Usuários: O Google costuma oferecer um crédito inicial (geralmente $300) para novos cadastros testarem qualquer serviço.

• Programa Estudantil: Através do Google Cloud Skills Boost, estudantes de instituições parceiras podem obter créditos e acesso a laboratórios práticos.

• Free Tier (Nível Gratuito): Existem recursos (como instâncias de máquinas virtuais específicas) que são gratuitos "para sempre", dentro de limites mensais de uso.

⚠️ Atenção: Os termos do Free Tier e créditos podem mudar. Sempre configure um Alerta de Orçamento (Budget Alert). A nuvem é elástica: se algo for configurado errado, ela vai escalar — e a cobrança no seu cartão também.

2. Os Pilares da Engenharia de Cloud: Camadas 4 vs. 7 (Modelo OSI)

Um engenheiro de nuvem precisa dominar o tráfego de rede. Quando falamos em "Camadas", estamos nos referindo ao Modelo OSI (Open Systems Interconnection), um padrão mundial que divide a comunicação de rede em 7 níveis. No GCP, entender as camadas superiores é vital:

• Camada 4 (Transporte): Foca na velocidade bruta. O balanceador L4 roteia pacotes com base em IPs e portas (TCP/UDP). É ideal para aplicações onde a performance é crítica e não é necessário "olhar" o que está dentro do pacote.

• Camada 7 (Aplicação): É o "cérebro" da rede. Ele entende o conteúdo da mensagem (HTTP/S), como URLs, cookies e cabeçalhos. Isso permite direcionar o tráfego de /video para um grupo de servidores e /pagamentos para outro, otimizando custos e experiência do usuário.

3. Como se tornar um Engenheiro de Cloud de elite?

A exigência por qualidade subiu. Para se preparar de forma sólida:

• Mão na massa (Hands-on): Não apenas siga tutoriais. Entenda a lógica, como o uso de variáveis $(hostname) em scripts de automação para identificar instâncias em tempo real.

• Certificações: O exame Associate Cloud Engineer é o ponto de partida ideal. Ele valida se você sabe operar tanto o Console quanto a linha de comando (gcloud).

• Resiliência com MIGs: Aprenda sobre Managed Instance Groups. O poder da nuvem reside no Self-healing (auto-recuperação) e Auto-scaling (crescimento automático).

Conclusão

Dominar o GCP é uma jornada de prática contínua. Antes de subir seu primeiro projeto, explore os créditos e o Free Tier, mas mantenha sempre um olho no painel de faturamento. A automação e a inteligência de rede (Modelo OSI) são as ferramentas; a responsabilidade financeira é o que mantém o projeto viável.

Hoje, encerro essa série mostrando como conectei o cérebro (n8n) ao músculo (Evolution API).

1. A Conexão via API Key

Para o n8n mandar mensagens, ele precisa de autorização. No nosso arquivo de configuração, definimos uma Global API Key. No n8n, usamos o nó "HTTP Request". É simples:

• Método: POST

• URL: https://api.meudominio.com.br/message/sendText

• Header: apikey: minha-senha-secreta

2. O Teste de Fogo

Criei um fluxo simples: Um Webhook que recebe dados -> Um nó que formata o texto -> O pedido para a API. Ao clicar em "Execute", a mágica aconteceu. O servidor na Oracle (que não me custou nada) processou o dado, falou com o container do WhatsApp e a notificação apitou no meu bolso. Sem atraso.

3. Valeu a pena?

Vamos aos números finais:

• Custo de Hardware: R$ 0,00 (Oracle Always Free).

• Custo de Licença: R$ 0,00 (Open Source).

• Custo de Domínio: R$ 40,00/ano (A única coisa que paguei).

• Economia estimada: R$ 200,00 a R$ 300,00 por mês comparado a soluções SaaS ou VPS pagas.

Mas o maior ganho não foi financeiro. Foi o conhecimento. Agora tenho controle total dos meus dados, da minha segurança e da minha infraestrutura.

Obrigado a quem acompanhou essa saga! Em 2026 tem muito mais. Feliz Natal!

Today, I wrap up this series by showing how I connected the brain (n8n) to the muscle (Evolution API).

1. The API Key Connection

For n8n to send messages, it needs authorization. In our configuration file, we defined a Global API Key. In n8n, we use the "HTTP Request" node. It's simple:

• Method: POST

• URL: https://api.mydomain.com/message/sendText

• Header: apikey: my-secret-password

2. The Fire Test

I created a simple flow: A Webhook that receives data -> A node that formats the text -> The request to the API. Clicking "Execute", the magic happened. The Oracle server (which cost me nothing) processed the data, talked to the WhatsApp container, and the notification buzzed in my pocket. Zero delay.

3. Was it worth it?

Let's look at the final numbers:

• Hardware Cost: $0.00 (Oracle Always Free).

• License Cost: $0.00 (Open Source).

• Domain Cost: ~$10.00/year (The only thing I paid for).

• Estimated Savings: $40.00 to $60.00 per month compared to SaaS or paid VPS solutions.

But the biggest gain wasn't financial. It was knowledge. I now have total control over my data, my security, and my infrastructure.

Thanks to everyone who followed this saga! Much more to come in 2026. Merry Christmas!

Se fôssemos instalar o n8n e a Evolution API do jeito "antigo", teríamos que baixar arquivos, instalar dependências do Node.js, configurar banco de dados na mão... um pesadelo.

Mas como estamos usando Docker, vamos usar a estratégia do "Combo" com o Docker Compose.

1. A Receita do Bolo (O Arquivo Mágico)

O Docker Compose permite escrever uma "receita" num arquivo de texto. Nós dizemos: "Quero um banco Postgres, um cache Redis, a API do WhatsApp e o n8n. E quero que todos conversem entre si."

Acesse a pasta do seu projeto (cd ~/n8n) e edite o arquivo (nano docker-compose.yml). Apague o que tiver lá e cole esta Stack Completa:

YAML

services:
  # 1. Banco de Dados (Postgres para Evolution)
  postgres:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_USER: evolution
      POSTGRES_PASSWORD: evolution_password
      POSTGRES_DB: evolution
    volumes:
      - evolution_db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U evolution"]
      interval: 5s
      timeout: 5s
      retries: 5

  # 2. Cache (Redis para Evolution)
  redis:
    image: redis:alpine
    restart: always
    command: ["redis-server", "--appendonly", "no"]

  # 3. Evolution API v2 (O WhatsApp)
  evolution:
    image: atendai/evolution-api:v2.2.2
    restart: always
    ports:
      - "8080:8080"
    environment:
      - SERVER_URL=https://api.SEUDOMINIO.com.br
      - AUTHENTICATION_API_KEY=[SUA-CHAVE-APY-VAI-AQUI]
      - DATABASE_ENABLED=true
      - DATABASE_PROVIDER=postgresql
      - DATABASE_CONNECTION_URI=postgresql://evolution:evolution_password@postgres:5432/evolution
      - CACHE_REDIS_ENABLED=true
      - CACHE_REDIS_URI=redis://redis:6379/0
      - DEL_INSTANCE=false
      # Truque para evitar desconexão do WhatsApp Web
      - CONFIG_SESSION_PHONE_VERSION=2.3000.1019430043
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started

  # 4. n8n (A Automação)
  n8n:
    image: docker.n8n.io/n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=n8n.SEUDOMINIO.com.br
      - WEBHOOK_URL=https://n8n.SEUDOMINIO.com.br/
      - GENERIC_TIMEZONE=America/Sao_Paulo
      - TZ=America/Sao_Paulo
      - N8N_SECURE_COOKIE=false
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:
  evolution_db:

2. O Segredo da Integração (Networking)

A mágica acontece na rede interna do Docker. Quando você for conectar o n8n na Evolution API, não use o endereço externo (https://api...). Use o endereço interno da rede Docker:

👉 URL: http://evolution:8080

Isso faz com que o n8n converse diretamente com o container do WhatsApp via cabo de rede virtual, sem sair para a internet. É mais seguro, instantâneo e não passa pelo firewall.

3. O Comando de Lançamento

Depois de salvar o arquivo (Ctrl+O, Ctrl+X), a mágica acontece com apenas três palavras no terminal:

Bash

docker compose up -d

O servidor vai baixar as imagens, criar os bancos de dados e conectar tudo. Em cerca de 2 minutos, você terá uma infraestrutura de nível empresarial rodando na sua máquina gratuita.

Na quinta-feira, vamos para o teste final: fazer o primeiro envio de mensagem!

If we were to install n8n and Evolution API the "old way," we'd have to download files, install Node.js dependencies, configure databases manually... a nightmare.

But since we are using Docker, we'll use the "Combo" strategy with Docker Compose.

1. The Recipe (The Magic File)

Docker Compose allows us to write a "recipe" in a text file. We say: "I want a Postgres database, a Redis cache, the WhatsApp API, and n8n. And I want them all to talk to each other."

Go to your project folder (cd ~/n8n) and edit the file (nano docker-compose.yml). Delete whatever is inside and paste this Full Stack:

YAML

services:
  # 1. Database (Postgres for Evolution)
  postgres:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_USER: evolution
      POSTGRES_PASSWORD: evolution_password
      POSTGRES_DB: evolution
    volumes:
      - evolution_db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U evolution"]
      interval: 5s
      timeout: 5s
      retries: 5

  # 2. Cache (Redis for Evolution)
  redis:
    image: redis:alpine
    restart: always
    command: ["redis-server", "--appendonly", "no"]

  # 3. Evolution API v2 (WhatsApp)
  evolution:
    image: atendai/evolution-api:v2.2.2
    restart: always
    ports:
      - "8080:8080"
    environment:
      - SERVER_URL=https://api.YOURDOMAIN.com
      - AUTHENTICATION_API_KEY=[YOUR-AUTHENTICATION-KEY-GOES-HERE]
      - DATABASE_ENABLED=true
      - DATABASE_PROVIDER=postgresql
      - DATABASE_CONNECTION_URI=postgresql://evolution:evolution_password@postgres:5432/evolution
      - CACHE_REDIS_ENABLED=true
      - CACHE_REDIS_URI=redis://redis:6379/0
      - DEL_INSTANCE=false
      # Trick to prevent WhatsApp Web disconnection
      - CONFIG_SESSION_PHONE_VERSION=2.3000.1019430043
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started

  # 4. n8n (Automation)
  n8n:
    image: docker.n8n.io/n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=n8n.YOURDOMAIN.com
      - WEBHOOK_URL=https://n8n.YOURDOMAIN.com/
      - GENERIC_TIMEZONE=America/Sao_Paulo
      - TZ=America/Sao_Paulo
      - N8N_SECURE_COOKIE=false
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:
  evolution_db:

2. The Integration Secret (Networking)

The magic happens in Docker's internal network. When connecting n8n to the Evolution API, do not use the external address (https://api...). Use the internal Docker network address:

👉 URL: http://evolution:8080

This allows n8n to talk directly to the WhatsApp container via a virtual network cable, without going out to the internet. It is safer, instant, and bypasses the firewall.

3. The Launch Command

After saving the file (Ctrl+O, Ctrl+X), the magic happens with just three words in the terminal:

Bash

docker compose up -d

The server will download the images, create the databases, and connect everything. In about 2 minutes, you will have enterprise-grade infrastructure running on your free machine.

On Thursday, we go for the final test: sending the first message!

1. Abrir portas no firewall (80, 443, 8080).

2. Configurar redirecionamento no roteador (NAT).

3. Expor o IP real do seu servidor para o mundo.

4. Sofrer configurando certificados SSL (aquele cadeado verde) que expiravam a cada 3 meses.

Esqueça isso. Existe um jeito muito melhor, mais seguro e gratuito: Cloudflare Tunnel.

Hoje, vou mostrar como conectei meu servidor Oracle ao mundo sem abrir nenhuma porta de entrada.

1. O Conceito de Túnel

Imagine que, em vez de abrir a porta da frente da sua casa para receber visitas, você cavasse um túnel subterrâneo secreto que sai direto dentro da sala segura do Cloudflare. É isso que o cloudflared faz. Ele cria uma conexão de saída criptografada. Ninguém na internet consegue "bater" no meu servidor, porque não há portas abertas.

2. Configuração via Arquivo (YAML)

Para manter o controle total, configurei o túnel usando um arquivo config.yml dentro do servidor. A mágica acontece no roteamento:

YAML

ingress:
  - hostname: n8n.meudominio.com.br
    service: http://localhost:5678
  - hostname: api.meudominio.com.br
    service: http://localhost:8080

Veja que incrível: o Cloudflare recebe o acesso no subdomínio n8n e entrega direto na porta 5678 interna do meu Docker. O mundo vê HTTPS seguro, mas meu servidor nem sabe o que é SSL.

3. Webhook Seguro

Também configurei uma rota para webhook.meudominio.com.br. Isso permite que sistemas externos enviem dados para minhas automações com total segurança e velocidade.

Conclusão da Semana 2 Temos a máquina, temos o Docker, temos memória sobrando (Swap) e temos uma conexão blindada. O palco está montado. Na próxima semana, começa o show: vamos instalar e integrar o n8n e a Evolution API.

1. Open firewall ports (80, 443, 8080).

2. Configure router forwarding (NAT).

3. Expose your server's real IP to the world.

4. Suffer configuring SSL certificates (that green padlock) that expired every 3 months.

Forget that. There is a much better, safer, and free way: Cloudflare Tunnel.

Today, I'll show you how I connected my Oracle server to the world without opening any entry ports.

1. The Tunnel Concept

Imagine that instead of opening your front door to receive visitors, you dug a secret underground tunnel that leads straight into Cloudflare's secure room. That's what cloudflared does. It creates an encrypted outbound connection. No one on the internet can "knock" on my server because there are no open ports.

2. Configuration via File (YAML)

To maintain total control, I configured the tunnel using a config.yml file inside the server. The magic happens in the routing:

YAML

ingress:
  - hostname: n8n.mydomain.com
    service: http://localhost:5678
  - hostname: api.mydomain.com
    service: http://localhost:8080

Look how amazing this is: Cloudflare receives access on the n8n subdomain and delivers it straight to the internal port 5678 of my Docker. The world sees secure HTTPS, but my server doesn't even know what SSL is.

3. Secure Webhook

I also configured a route for webhook.mydomain.com. This allows external systems to send data to my automations with total security and speed.

Week 2 Conclusion We have the machine, we have Docker, we have spare memory (Swap), and we have an armored connection. The stage is set. Next week, the show begins: we will install and integrate n8n and Evolution API.

And we have an extra challenge: since we are using the AMD Micro instance (free tier), we only have 1GB of RAM. If we try to run n8n and a WhatsApp API here, the server will crash in 5 minutes.

I'll show you how I solved this using an old SysAdmin trick: Swap.

1. The "Root" Docker Installation

We could use fancy panels, but they consume memory. On small machines, every megabyte counts. That's why I did the installation via the terminal, which is clean and efficient:

Bash

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

Simple as that. With this, we have the most powerful container engine in the world ready to run.

2. The 1GB RAM Problem

Modern applications like Evolution API (for WhatsApp) use browsers behind the scenes. They "eat" memory. With only 1GB of physical RAM, Linux triggers the OOM Killer (Out of Memory Killer) and shuts down your programs out of nowhere.

The solution? Create Virtual Memory (Swap) using hard drive space.

3. Creating 4GB of "Extra Memory"

Since Oracle gives us 50GB of disk space, I decided to allocate 4GB for Swap. This works like a "lung": when RAM fills up, the server uses the disk so it doesn't freeze.

The process involves creating a file, setting security permissions, and telling Linux to use it:

Bash

sudo fallocate -l 4G /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

I also adjusted Swappiness to 10, ensuring the system prioritizes fast RAM and only uses the disk in emergencies.

Result: We now have a server "armored" against memory shortages, ready to host n8n and Evolution API without fear of crashes.

On Thursday, I will reveal how I access all of this externally without opening a single security port on the firewall.

E temos um desafio extra: como estamos usando a instância AMD Micro (gratuita), temos apenas 1GB de memória RAM. Se tentarmos rodar o n8n e uma API de WhatsApp aqui, o servidor vai travar em 5 minutos.

Vou mostrar como resolvi isso usando um truque antigo de SysAdmin: o Swap.

1. A Instalação "Raiz" do Docker

Poderíamos usar painéis bonitos, mas eles consomem memória. Em máquinas pequenas, cada megabyte conta. Por isso, fiz a instalação via terminal, que é limpa e eficiente:

Bash

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

Simples assim. Com isso, temos o motor de containers mais poderoso do mundo pronto para rodar.

2. O Problema do 1GB de RAM

Aplicações modernas como o Evolution API (para WhatsApp) usam navegadores por trás dos panos. Eles "comem" memória. Com apenas 1GB físico, o Linux aciona o OOM Killer (assassino de falta de memória) e fecha seus programas do nada.

A solução? Criar uma Memória Virtual (Swap) usando o espaço do disco rígido.

3. Criando 4GB de "Memória Extra"

Como a Oracle nos dá 50GB de disco, decidi alocar 4GB para Swap. Isso funciona como um "pulmão": quando a memória RAM enche, o servidor usa o disco para não travar.

O processo envolve criar um arquivo, definir permissões de segurança e avisar o Linux para usá-lo:

Bash

sudo fallocate -l 4G /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

Também ajustei o Swappiness para 10, garantindo que o sistema priorize a RAM rápida e só use o disco em emergências.

Resultado: Agora temos um servidor "blindado" contra falta de memória, pronto para receber o n8n e o Evolution API sem medo de travamentos.

Na quinta-feira, vou revelar como acesso tudo isso externamente sem abrir nenhuma porta de segurança no firewall.

Parece simples: "Criar Instância", "Baixar Chave", "Conectar". Mas quem já mexeu com Linux e Cloud sabe que o buraco é mais embaixo.

1. A Escolha da Máquina (O nosso "Fusquinha")

O sonho de consumo na Oracle é a instância Ampere (ARM) com 24GB de RAM. Mas, como ela é muito disputada, muitas vezes não tem capacidade disponível. A estratégia? Não ficar parado. Provisionei uma instância AMD Micro (E2.1). Tem apenas 1GB de RAM e 2 CPUs, mas é suficiente para começar.

• Dica de Ouro: Escolhi o Ubuntu 24.04 como sistema operacional. É estável, moderno e tem tutorial para tudo na internet.

2. O Desafio das Chaves SSH

Diferente de um cPanel onde você tem um usuário e senha, na Cloud profissional usamos Chaves SSH. É um arquivo (.key) que funciona como uma chave física de casa. O problema começa quando você tenta usar essa chave no terminal.

O erro clássico que enfrentei: WARNING: UNPROTECTED PRIVATE KEY FILE!

O Linux é paranoico (com razão). Se a sua chave estiver numa pasta onde "outros usuários" do computador podem ler, ele bloqueia o acesso na hora. A solução não é óbvia para quem vem do Windows:

Bash

chmod 600 minha-chave.key

Esse comando diz ao sistema: "Apenas eu leio isso. Ninguém mais." Foi o primeiro "estalo" de que agora sou eu quem manda na segurança.

3. Entrando como um Profissional (O Arquivo Config)

Depois de corrigir as permissões, digitar ssh -i caminho/da/chave ubuntu@123.123.123.123 toda vez cansa demais. Descobri que podemos criar um "atalho" no arquivo ~/.ssh/config do nosso computador:

Plaintext

Host oracle
    HostName 123.123.123.123
    User ubuntu
    IdentityFile ~/.ssh/minha-chave.key

Agora, basta digitar ssh oracle no terminal e estou dentro.

4. E o Firewall?

Ao entrar, a primeira coisa que notei: o firewall da Oracle (Security Lists) bloqueia tudo por padrão. Tentar abrir a porta 80 ou 443 exige configurações chatas no painel da Cloud e no iptables da máquina. Mas não vamos sofrer com isso. Na próxima semana, vou mostrar como contornei todo o firewall usando Túneis Cloudflare, expondo meus serviços com HTTPS sem abrir um único buraco na segurança do servidor.

Resumo da Semana 1: Temos um servidor Linux gratuito, atualizado e com acesso SSH configurado e seguro. A fundação está pronta. Na próxima terça-feira, vamos instalar o motor que fará tudo funcionar: o Docker.

It sounds simple: "Create Instance", "Download Key", "Connect". But anyone who has dealt with Linux and Cloud knows it's never that straightforward.

1. Choosing the Machine (Our "Little Beetle")

The dream setup on Oracle is the Ampere (ARM) instance with 24GB of RAM. However, since it's highly sought after, capacity is often unavailable. The strategy? Don't stand still. I provisioned an AMD Micro (E2.1) instance. It only has 1GB of RAM and 2 CPUs, but it's enough to get started.

• Pro Tip: I chose Ubuntu 24.04 as the operating system. It's stable, modern, and has tutorials for everything.

2. The SSH Key Challenge

Unlike cPanel where you have a login password, in professional Cloud environments, we use SSH Keys. It's a file (.key) that acts like a physical key. The trouble starts when you try to use this key in the terminal.

The classic error I faced: WARNING: UNPROTECTED PRIVATE KEY FILE!

Linux is paranoid (rightfully so). If your key is in a folder where "other users" can read it, it blocks access. The solution isn't obvious for Windows users:

Bash

chmod 600 my-key.key

This command tells the system: "Only I read this. No one else." It was the first realization that I am now the one in charge of security.

3. Connecting Like a Pro (The Config File)

After fixing permissions, typing ssh -i path/to/key ubuntu@123.123.123.123 every time gets tiring. I discovered we can create a "shortcut" in our computer's ~/.ssh/config file:

Plaintext

Host oracle
    HostName 123.123.123.123
    User ubuntu
    IdentityFile ~/.ssh/my-key.key

Now, I just type ssh oracle in the terminal and I'm in.

4. What About the Firewall?

Upon entering, the first thing I noticed: Oracle's firewall (Security Lists) blocks everything by default. Trying to open port 80 or 443 requires complex configurations in the Cloud panel and the machine's iptables. But we won't suffer through that. Next week, I'll show how I bypassed the entire firewall using Cloudflare Tunnels, exposing my services with HTTPS without punching a single hole in the server's security.

Week 1 Summary: We have a free Linux server, updated, and with SSH access configured and secure. The foundation is laid. Next Tuesday, we will install the engine that will run everything: Docker.

The obvious solution would be to rent a robust VPS (Virtual Private Server) on DigitalOcean or AWS. But to get a machine with 4 CPUs and 24GB of RAM, the bill would easily exceed $40 or $50 per month. For those starting out or scaling an operation, this fixed cost adds up.

That's when I decided to accept a challenge: Build an "Enterprise-level" infrastructure spending exactly $0.00.

Sounds too good to be true? I thought so too. But then I discovered the Oracle Cloud Always Free Tier.

The Dream Setup (For Free)

Unlike other providers that offer "free trials" for 30 days, Oracle offers (if you can snag a spot) an ARM Ampere machine with up to 4 OCPUs and 24GB of RAM forever. Even when that machine is unavailable, we can use AMD Micro instances, which are modest but perfect for validating test environments and running lightweight services via Docker.

In this new technical journey, I migrated my automations there and achieved:

• Pure Docker: Total control over versions and containers.

• Self-hosted n8n: No execution limits.

• Evolution API v2: Professional WhatsApp integration.

• Cloudflare Tunnel: The icing on the cake. I achieved secure HTTPS and external access without opening a single port on the firewall or exposing the server IP.

It's Not All Roses: The Challenges

I won't lie: it's not "click and install." Leaving the comfort zone of ready-made hosting requires getting your hands dirty in the terminal. We had to deal with SSH keys, Linux file permissions, Swap configuration (virtual memory), and YAML files that don't forgive a single misplaced space.

But the result is worth it. I now have a server that is mine, secure, and extremely performant.

Follow the Series

Over the coming weeks, I will document the technical step-by-step of this implementation here on the blog. If you want to learn how to set up your own automation server with no licensing costs, stay tuned.

Next Thursday, I will explain the first critical step: How to create the account, generate security keys, and access the server without getting locked out.

See you there!

A solução óbvia seria contratar um VPS (Servidor Privado Virtual) robusto na DigitalOcean ou AWS. Mas para ter uma máquina com 4 CPUs e 24GB de RAM, a conta passaria facilmente dos R$ 150,00 ou R$ 200,00 por mês. Para quem está no início ou a ponto de escalar uma operação, esse custo fixo pesa.

Foi aí que decidi aceitar um desafio: Montar uma infraestrutura de nível "Enterprise" gastando exatamente R$ 0,00.

Parece bom demais para ser verdade? Pois é, eu também achava. Mas descobri o Oracle Cloud Always Free Tier.

O Setup dos Sonhos (E Gratuito)

Diferentemente de outros provedores que oferecem "amostras grátis" por 30 dias, a Oracle disponibiliza (se houver capacidade de instanciação na zona escolhida) uma máquina ARM Ampere com até 4 OCPUs e 24GB de RAM de forma permanente. Mesmo quando essa máquina está indisponível, conseguimos usar as instâncias AMD Micro, que são modestas, mas perfeitas para validar ambientes de teste e rodar serviços leves via Docker.

Nesta nova jornada técnica, migrei as minhas automações para lá e consegui:

• Docker Puro: Controle total sobre as versões e containers.

• n8n Auto-hospedado: Sem limites de execução.

• Evolution API v2: Integração profissional com WhatsApp.

• Cloudflare Tunnel: A cereja no topo do bolo. Consegui HTTPS seguro e acesso externo sem precisar abrir uma única porta no firewall ou expor o IP do servidor.

Nem tudo são flores: Os Desafios

Não vou mentir: não é "clicar e instalar". Sair da zona de conforto das hospedagens prontas exige sujar as mãos no terminal. Tive que lidar com chaves SSH, permissões de arquivos Linux, configuração de Swap (memória virtual) e arquivos YAML que não perdoam um espaço fora do lugar.

No entanto, o resultado final vale a pena. Agora possuo um servidor próprio, seguro e com alta performance, e ainda pude aprimorar minhas competências em DevOps.

Acompanha a Série

Acompanhe o blog nas próximas semanas! Vou detalhar, passo a passo e de forma técnica, como implementei este servidor de automação. Se o seu objetivo é aprender a montar o seu próprio servidor sem custos de licença, não perca.

Na próxima quinta-feira, vou explicar o primeiro passo crítico: Como criar a conta, gerar as chaves de segurança e aceder ao servidor sem ficar trancado do lado de fora.

Até lá!

The tool choice was obvious: DaVinci Resolve. It’s professional and offers the necessary organization and logging features to handle such a massive amount of footage.

The Linux "Elephant in the Room"

However, it wasn't smooth sailing. When we imported the files into the free version of DaVinci Resolve on Linux, we hit a brick wall: the software doesn't natively recognize the standard audio and video formats from most mobile phones (like H.264/H.265 codecs and AAC audio). The result? A screen full of "Media Offline" warnings for 500 files.

The industry-standard solution is transcoding to edit-friendly formats (like ProRes or DNxHR). But doing this manually, file by file, for hundreds of videos—and for new materials that kept arriving during the process—was humanly impossible. We needed a fast, automated solution.

The Inspiration: The Open Source Legacy

Remembering the culture of sharing, I turned to a classic solution from the Brazilian Linux community as a foundation: a script created years ago by Henrique from the Diolinux team and adapted by Mateus Müller. The structure was solid, but it needed an urgent update to handle the volume and variety of our modern workflow.

AI Acceleration: Pair Programming to Solve the Problem

With the school project deadline looming, there was no time to spend hours reading ffmpeg documentation or testing Bash loops. This is where the key to modern productivity stepped in: the use of AI with Gemini.

We took the original script and transformed it into a robust, hybrid tool. The process was accelerated learning focused squarely on solving the real-world problem: I defined the needs ("it needs to convert WhatsApp audio too," "it has to organize everything into subfolders so she doesn't get lost"), and the AI suggested the best technical implementations in seconds, explaining every line.

The Result: to_davinci.sh v2.0

The result was the salvation of the project. We created a script that:

• Recursively scans the media folders she receives.

• Automatically identifies if it's video (MP4, MOV) or audio (M4A, MP3 from WhatsApp).

• Applies the correct "recipe" for each (Video -> MPEG4/PCM; Audio -> WAV/PCM), generating files that DaVinci loves.

• Automatically organizes everything into "converted" subfolders.

It was a massive problem solved by uniting the legacy of open source with the speed of artificial intelligence. You can check out the full code we used, the usage manual, and drop a star on the GitHub repository below.

https://github.com/paulorabelo/to-davinci-media-converter

A escolha da ferramenta era óbvia: o DaVinci Resolve. Ele é profissional e oferece os recursos de organização e decupagem necessários para lidar com essa quantidade massiva de material.

O "Elefante na Sala" do Linux

Mas, nem tudo são flores. Quando importamos os arquivos para a versão gratuita do DaVinci Resolve no Linux, esbarramos em uma parede: o software não reconhece nativamente os formatos de áudio e vídeo padrão da maioria dos celulares (como codecs H.264/H.265 e áudio AAC). O resultado? Uma tela cheia de "Mídia Offline" para 500 arquivos.

A solução padrão da indústria é transcodificar para formatos "amigáveis" à edição (como ProRes ou DNxHR). Mas fazer isso manualmente, arquivo por arquivo, para centenas de vídeos — e para os novos materiais que continuavam chegando durante o processo — era humanamente inviável. Precisávamos de uma solução rápida e automática.

A Inspiração: O Legado do Software Livre

Lembrando da cultura do compartilhamento, recorri a uma solução clássica da comunidade brasileira para usar como base: um script criado anos atrás pelo Henrique da equipe do Diolinux e adaptado pelo Mateus Müller. A estrutura era sólida, mas precisava de uma atualização urgente para lidar com o volume e a variedade do nosso fluxo de trabalho moderno.

A Aceleração com IA: Programando em Dupla para Resolver o Problema

Com a urgência do projeto escolar batendo à porta, não dava para passar horas lendo documentação do ffmpeg e testando loops em Bash. Aqui entrou a peça chave da produtividade moderna: o uso da inteligência artificial, o Gemini.

Pegamos o script original e o transformamos em uma ferramenta híbrida e robusta. O processo foi de um aprendizado acelerado focado na resolução do problema real: eu definia a necessidade ("precisa converter os áudios do WhatsApp também", "tem que organizar tudo em subpastas para ela não se perder"), e a IA sugeria as melhores implementações técnicas em segundos, explicando cada linha.

O Resultado: to_davinci.sh v2.0

O resultado foi a salvação do projeto. Criamos um script que:

• Varre recursivamente as pastas de mídia que ela recebe.

• Identifica automaticamente se é vídeo (MP4, MOV) ou áudio (M4A, MP3 do WhatsApp).

• Aplica a "receita" correta para cada um (Vídeo -> MPEG4/PCM; Áudio -> WAV/PCM), gerando arquivos que o DaVinci adora.

• Organiza tudo automaticamente em pastas de "convertidos".

Foi um problema grande resolvido com a união do legado do software livre e a velocidade da inteligência artificial. Você pode conferir o código completo que usamos, o manual de uso e deixar sua estrela no repositório do GitHub abaixo.

https://github.com/paulorabelo/to-davinci-media-converter

Como estou cursando Engenharia de Computação e já atuo com desenvolvimento, decidi unir o útil ao agradável (e inovador). E se o meu terminal pudesse não apenas executar comandos, mas entender o que estou fazendo?

Foi assim que nasceu meu projeto de final de semana: um assistente CLI integrado à API do Google Gemini.

A Engenharia por trás da "Mágica" 🛠️

A ideia não era criar um chatbot complexo, mas sim uma ferramenta que se integrasse ao fluxo nativo do Unix/Linux. Para isso, usei três ingredientes principais:

1. Python & Venv: Para a lógica de script e isolamento do ambiente (boas práticas sempre!).

2. Google Gemini API (Modelo 2.0 Flash): Pela velocidade insana e custo zero para desenvolvedores no tier gratuito.

3. Unix Pipes (|): A cereja do bolo.

💡 Um toque de Engenharia de Software: Segurança

Durante o desenvolvimento, uma decisão importante foi como gerenciar a chave da API. Em vez de colocá-la direto no código (o que é uma falha de segurança grave conhecida como hardcoding), optei por usar Variáveis de Ambiente do sistema operacional.

Isso segue o princípio de "Configuração" da metodologia The Twelve-Factor App, padrão ouro em desenvolvimento moderno. O código fica limpo e seguro no GitHub, enquanto a chave secreta fica guardada apenas na configuração local do meu terminal (.zshrc).

O Poder do Pipe (|) + LLM

A grande sacada foi implementar a leitura do STDIN (Standard Input). Isso permite que eu faça encadeamentos como:

Bash

cat erro_gigante.log | ajuda "Onde está a falha aqui?"

Ou até mesmo listar arquivos e pedir explicações contextuais:

Bash

ls -la | ajuda "Qual script Python desta pasta é o mais pesado?"

O script captura a saída do comando anterior, anexa minha pergunta e envia tudo para a IA, que atua como um "Engenheiro Sênior" me dando a resposta mastigada direto no terminal.

Por que isso importa?

Estamos vivendo a era da IA, mas muitas vezes ficamos presos ao "copia e cola" do navegador. Trazer a inteligência artificial para dentro do terminal (CLI) elimina o atrito. Eu não saio do meu ambiente de trabalho, mantenho o foco e resolvo problemas em segundos.

Isso é a essência da Engenharia de Computação: usar as ferramentas disponíveis para otimizar processos e criar soluções elegantes.

E você, já pensou em integrar IA nos seus scripts do dia a dia? O código é mais simples do que parece! Se quiser dar uma olhadinha o código está disponível no Github abaixo:

GitHub: https://github.com/paulorabelo/terminal-ai

As a Computer Engineering student already working in development, I decided to combine utility with innovation. I asked myself: What if my terminal could not just execute commands, but actually understand context?

That’s how my weekend project was born: a native CLI assistant integrated directly with the Google Gemini API.

The Engineering Behind the "Magic" 🛠️

The goal wasn't to build a complex, standalone chatbot application. I wanted a tool that integrated seamlessly into the native Unix/Linux workflow. To achieve this, I used three key ingredients:

1. Python & Venv: For robust scripting logic and environment isolation (always following best practices!).

2. Google Gemini API (Model 2.0 Flash): Chosen for its insane speed and zero cost for developers on the free tier.

3. Unix Pipes (|): The real game-changer.

💡 A touch of Software Engineering: Security

During development, a crucial decision was how to manage the API key. Instead of hardcoding it directly into the source code (a major security flaw), I chose to use OS Environment Variables.

This follows the "Config" principle of the The Twelve-Factor App methodology, a gold standard in modern development. The code remains clean and safe on GitHub, while the secret key is stored securely only in my local terminal configuration (.zshrc).

The Power of the Pipe (|) + LLM

The breakthrough feature was implementing the reading of STDIN (Standard Input) in the Python script. This allows for powerful command chaining.

Instead of copy-pasting errors into a browser, I can now do this:

Bash

cat giant_error.log | ajuda "Where is the critical failure here?"

Or even list files and ask for contextual explanations based on metadata:

Bash

ls -la | ajuda "Which Python script in this folder is the largest, and what does its name suggest it does?"

The script captures the stdout of the previous command, appends my specific question, and sends the payload to the AI. The AI then acts like a "Senior Engineer," delivering a concise, readable answer straight back to my terminal output.

Why This Matters

We are living in the AI era, yet we often find ourselves stuck in the "browser copy-paste loop." Bringing Artificial Intelligence directly inside the terminal (CLI) eliminates this friction.

I don't have to leave my development environment, I maintain my flow state, and I solve problems in seconds. To me, this is the essence of Computer Engineering: leveraging available tools to optimize processes and create elegant solutions.

What about you? Have you thought about integrating AI into your daily automation scripts? The code is often simpler than it seems! You can find the full source code on GitHub:

GitHub: https://github.com/paulorabelo/terminal-ai

For GPU Passthrough, you'll need a processor that supports virtualization technology (like Intel VT-d or AMD-Vi), two GPUs (one for the host and one for the VM), and enough RAM for both the host and the VM. Not all hardware is compatible with GPU Passthrough. You'll need to check if your processor, motherboard, and GPUs support this technology.

KVM (Kernel-based Virtual Machine) is a full virtualization solution for Linux, while Virt-Manager is a graphical user interface for managing VMs. You'll need to install both on your system. IOMMU (Input-Output Memory Management Unit) is a technology that allows a device's hardware to directly access the system memory. It's required for GPU Passthrough and needs to be enabled in the BIOS.

After configuring VFIO, you'll need to update the initramfs to apply the changes. Now you can create the VM using Virt-Manager. During creation, you can select the 'Customize configuration before install' option and add your GPU as a PCI device. Finally, install the guest operating system on the VM. After it's installed, you can install the GPU drivers as usual.

Remember that GPU Passthrough is an advanced technique that may require a lot of troubleshooting. Always back up your data before you start and don't hesitate to seek help if you run into problems.

One of the most promising and sought-after careers today is that of a software developer. Software developers are responsible for creating, testing, and maintaining computer programs that meet the needs of users. They can work in a variety of areas, such as games, applications, operating systems, artificial intelligence, etc.

But how do you become a software developer at 40? Do you need a specific degree or advanced knowledge of mathematics? How long does it take to learn to program? What are the best programming languages ​​to start with? These are some of the questions you may be asking yourself. In this post, we will try to answer these and other questions and give you some tips to start your journey as a software developer.

First, it is important to know that there is no single way or path to become a software developer. Each person has their own pace, style and learning preferences. In addition, there are different types and levels of software development, which require different skills and knowledge.

A basic concept that you need to understand is the difference between backend, frontend and fullstack. The backend is the part of the software that is "behind" the graphical interface, that is, it is the code that handles the logic, data and communication with other systems. The frontend is the part of the software that is "in front" of the graphical interface, that is, it is the code that defines how the software appears to the user, such as colors, buttons, menus, etc. The fullstack is the combination of the backend and the frontend, that is, it is the developer who masters both areas.

Depending on the type of software you want to create, you can either specialize in one of these areas or become a full-stack developer. Each area has its advantages and disadvantages, as well as its own most commonly used programming languages.

Programming languages ​​are the languages ​​that developers use to write software code. There are hundreds of different programming languages, each with its own characteristics, syntaxes, and applications. Some languages ​​are easier to learn than others, some are more popular than others, and some are better suited for certain types of software than others.

To start your career as a software developer at 40, you don't need to learn every programming language out there. In fact, that would be impossible and unnecessary. What you need to do is choose one or a few languages ​​that are relevant to your goal and that are compatible with your level of knowledge.

A good way to choose a programming language is to research which ones are most in demand in the market, which ones are most recommended for beginners, and which ones are best suited for the type of software you want to create. You can also consult online platforms that offer courses, tutorials and practical projects to learn how to program.

Some of the most popular and versatile programming languages ​​today are Java, C/C++ and Rust. Java is an object-oriented, cross-platform language widely used to develop applications for web, desktop and mobile devices. C/C++ are compiled, fast and powerful languages ​​used to develop operating systems, games and complex software. Rust is a modern, safe and efficient language used to develop high-performance and reliable software.

These are just some of the options you have to start your career as a software developer at 40 years old. The important thing is that you don't give up on your dream and that you are willing to learn and constantly update yourself. Remember that programming is a skill that develops with practice and experience. The more you program, the more you will learn and improve.

I hope this post was useful and inspiring for you. If you liked it, share it with your friends and leave a comment. See you next time!