16 min read oracle

Oracle Cloud: Configuração Inicial do Servidor

Oracle Cloud: Configuração Inicial do Servidor
Fonte da Imagem: https://oracle.com

Com o servidor criado e devidamente preparado no post anterior, damos continuidade ao processo entrando na fase de configuração.
Neste segundo post, detalho as configurações, ajustes e boas práticas necessárias para colocar o servidor em funcionamento de acordo com o objetivo proposto.
Aqui, o ambiente deixa de ser apenas uma estrutura básica e passa a operar de forma prática e funcional.

Passo 1: Instalação e Configuração do Servidor

Para melhor compreensão do processo como um todo, é recomendado iniciar pelo primeiro post.

Passo 1.1: Atualizando o Sistema

Primeiro, sempre atualize o sistema:

sudo apt update && sudo apt upgrade -y

Este comando faz duas coisas:

  • apt update: Atualiza a lista de pacotes disponíveis
  • apt upgrade -y: Instala as atualizações disponíveis (o -y confirma automaticamente)

Isso pode levar alguns minutos.

Passo 1.2: Configurando o Timezone

Configure o fuso horário correto:

sudo timedatectl set-timezone America/Sao_Paulo

Para ver outros timezones disponíveis:

timedatectl list-timezones

Verifique a configuração:

timedatectl

Passo 1.3: Configurando o Firewall do Ubuntu (UFW)

Ubuntu vem com UFW (Uncomplicated Firewall), mas não ativado por padrão. Vamos configurá-lo:

ATENÇÃO: É CRUCIAL fazer isso na ordem correta para não bloquear seu próprio acesso SSH!

# Permitir SSH primeiro (MUITO IMPORTANTE!)
sudo ufw allow 22/tcp

# Permitir HTTP
sudo ufw allow 80/tcp

# Permitir HTTPS
sudo ufw allow 443/tcp

# Se você vai usar outras portas, adicione aqui
# Exemplo: sudo ufw allow 3000/tcp

# Agora podemos habilitar o firewall
sudo ufw enable

Quando perguntado "Command may disrupt existing ssh connections. Proceed with operation (y|n)?", digite y.

Verifique o status:

sudo ufw status verbose

Você deve ver algo assim:

Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), disabled (routed)
New profiles: skip

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW IN    Anywhere
80/tcp                     ALLOW IN    Anywhere
443/tcp                    ALLOW IN    Anywhere

Passo 1.4: Configurando o Firewall do Oracle Linux (iptables)

A Oracle configura automaticamente iptables no Ubuntu para bloquear tráfego. Precisamos ajustar:

# Ver regras atuais
sudo iptables -L -n -v

# Permitir tráfego HTTP
sudo iptables -I INPUT 6 -m state --state NEW -p tcp --dport 80 -j ACCEPT

# Permitir tráfego HTTPS
sudo iptables -I INPUT 6 -m state --state NEW -p tcp --dport 443 -j ACCEPT

# Salvar as regras permanentemente
sudo netfilter-persistent save

Se o comando netfilter-persistent não funcionar, instale:

sudo apt install iptables-persistent -y

Durante a instalação, quando perguntado sobre salvar as regras atuais, selecione Yes.

Passo 1.5: Criando um Usuário Não-Root (Opcional mas Recomendado)

Por segurança, é bom criar um usuário separado para tarefas do dia a dia:

# Criar usuário
sudo adduser seunomedeusuario

# Adicionar ao grupo sudo (permissões administrativas)
sudo usermod -aG sudo seunomedeusuario

# Copiar chaves SSH para o novo usuário
sudo mkdir -p /home/seunomedeusuario/.ssh
sudo cp ~/.ssh/authorized_keys /home/seunomedeusuario/.ssh/
sudo chown -R seunomedeusuario:seunomedeusuario /home/seunomedeusuario/.ssh
sudo chmod 700 /home/seunomedeusuario/.ssh
sudo chmod 600 /home/seunomedeusuario/.ssh/authorized_keys

Teste a conexão com o novo usuário antes de sair:

# Em outro terminal
ssh -i sua-chave.key seunomedeusuario@SEU_IP

Passo 1.6: Instalando Ferramentas Essenciais

sudo apt install -y \
    curl \
    wget \
    git \
    vim \
    htop \
    net-tools \
    build-essential \
    software-properties-common \
    ufw \
    fail2ban

Explicação:

  • curl/wget: Ferramentas para download
  • git: Controle de versão
  • vim: Editor de texto
  • htop: Monitor de recursos do sistema
  • net-tools: Ferramentas de rede
  • build-essential: Compiladores C/C++
  • fail2ban: Proteção contra ataques de força bruta

Passo 1.7: Configurando Fail2Ban

Fail2ban protege contra ataques de força bruta:

sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Criar configuração personalizada:

sudo nano /etc/fail2ban/jail.local

Adicione:

[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 5

[sshd]
enabled = true
port = 22
logpath = /var/log/auth.log

Salve (Ctrl+O, Enter, Ctrl+X) e reinicie:

sudo systemctl restart fail2ban

Passo 1.8: Configurando SWAP (Memória Virtual)

Mesmo com 12 GB de RAM, ter swap é uma boa prática:

# Criar arquivo de swap de 2GB
sudo fallocate -l 2G /swapfile

# Definir permissões corretas
sudo chmod 600 /swapfile

# Marcar como swap
sudo mkswap /swapfile

# Ativar
sudo swapon /swapfile

# Verificar
sudo swapon --show
free -h

# Tornar permanente
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# Ajustar swappiness (quanto menor, menos usa swap)
echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Parte 2: Instalando e Configurando o Servidor Web (Nginx)

Nginx é um servidor web poderoso, leve e muito usado em produção.

Passo 6.1: Instalando o Nginx

sudo apt update
sudo apt install nginx -y

Passo 2.2: Iniciando e Habilitando o Nginx

# Iniciar o serviço
sudo systemctl start nginx

# Habilitar para iniciar automaticamente no boot
sudo systemctl enable nginx

# Verificar status
sudo systemctl status nginx

Passo 2.3: Testando o Nginx

Abra seu navegador e acesse: http://SEU_IP_PUBLICO

Você deve ver a página padrão do Nginx com a mensagem "Welcome to nginx!".

Se não funcionar, verifique:

  1. Firewall UFW está permitindo porta 80
  2. Security List da Oracle está permitindo porta 80
  3. iptables está configurado corretamente

Passo 2.4: Estrutura de Diretórios do Nginx

/etc/nginx/                 # Diretório principal de configuração
├── nginx.conf              # Configuração principal
├── sites-available/        # Sites disponíveis
├── sites-enabled/          # Sites habilitados (symlinks)
├── conf.d/                 # Configurações adicionais
└── snippets/               # Snippets reutilizáveis

/var/www/html/              # Diretório padrão dos arquivos web
/var/log/nginx/             # Logs do Nginx
├── access.log              # Log de acesso
└── error.log               # Log de erros

Passo 2.5: Configuração Básica de Segurança do Nginx

Edite a configuração principal:

sudo nano /etc/nginx/nginx.conf

Encontre a seção http { e adicione/modifique:

http {
    ##
    # Configurações básicas
    ##
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    server_tokens off;  # Oculta versão do Nginx
    
    ##
    # Limites de tamanho
    ##
    client_max_body_size 20M;
    client_body_buffer_size 128k;
    
    ##
    # Gzip
    ##
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css text/xml text/javascript 
               application/json application/javascript application/xml+rss 
               application/rss+xml font/truetype font/opentype 
               application/vnd.ms-fontobject image/svg+xml;
    
    # Resto da configuração...
}

Teste a configuração:

sudo nginx -t

Se estiver tudo OK, recarregue:

sudo systemctl reload nginx

Parte 3: Registrando e Configurando um Domínio

Passo 3.1: Adquirindo um Domínio

Você pode adquirir domínios em diversos registradores:

Opções Internacionais:

  • Namecheap: Preços competitivos, boa interface
  • Google Domains (atualmente gerenciado pelo Squarespace): Simples e integrado com Google Cloud
  • Cloudflare: Preços no custo, DNS rápido incluído
  • GoDaddy: Conhecido, mas mais caro

Opções Brasileiras:

  • Registro.br: Para domínios .br (mais barato, R$ 40/ano)
  • UOL Host: Revenda de .br e internacionais
  • HostGator Brasil: Domínios e hospedagem

Para este tutorial, vou usar um exemplo genérico. Vamos supor que você registrou: meublog.tech

Passo 3.2: Configurando os DNS Records

Após registrar o domínio, você precisa configurar os DNS records para apontar para seu servidor Oracle Cloud.

Acesse o painel de controle DNS do seu registrador e adicione os seguintes registros:

Registro A (IPv4)

Tipo: A
Nome: @  (ou deixe vazio, representa o domínio raiz)
Valor: SEU_IP_PUBLICO_ORACLE
TTL: 3600 (ou Auto)

Este registro faz meublog.tech apontar para seu servidor.

Registro A para www

Tipo: A
Nome: www
Valor: SEU_IP_PUBLICO_ORACLE
TTL: 3600

Este registro faz www.meublog.tech apontar para seu servidor.

Alternativa: Usando CNAME para www

Tipo: CNAME
Nome: www
Valor: meublog.tech  (ou @)
TTL: 3600

Exemplo Prático (no Cloudflare):

Tipo Nome Conteúdo Proxy TTL
A @ 140.238.123.45 DNS only Auto
A www 140.238.123.45 DNS only Auto

Importante:

  • Desative o proxy (nuvem laranja) inicialmente no Cloudflare até configurar SSL
  • A propagação DNS pode levar de minutos a 48 horas (geralmente 15-30 minutos)

Passo 3.3: Verificando a Propagação DNS

Você pode verificar se o DNS já está propagado:

No Linux/Mac:

dig meublog.tech
nslookup meublog.tech

No Windows:

nslookup meublog.tech

Online:

Procure por seu IP público nos resultados.

Passo 3.4: Configurando Virtual Host no Nginx

Agora que o domínio aponta para o servidor, vamos configurar o Nginx para servir o site.

Crie um arquivo de configuração para seu site:

sudo nano /etc/nginx/sites-available/meublog.tech

Adicione a seguinte configuração básica:

server {
    listen 80;
    listen [::]:80;
    
    server_name meublog.tech www.meublog.tech;
    
    root /var/www/meublog.tech/html;
    index index.html index.htm index.nginx-debian.html;
    
    # Logs específicos do site
    access_log /var/log/nginx/meublog.tech.access.log;
    error_log /var/log/nginx/meublog.tech.error.log;
    
    location / {
        try_files $uri $uri/ =404;
    }
    
    # Segurança adicional
    location ~ /\.ht {
        deny all;
    }
}

Passo 3.5: Criando a Estrutura de Diretórios

# Criar diretório para o site
sudo mkdir -p /var/www/meublog.tech/html

# Definir permissões corretas
sudo chown -R $USER:$USER /var/www/meublog.tech/html
sudo chmod -R 755 /var/www/meublog.tech

Passo 3.6: Criando uma Página de Teste

nano /var/www/meublog.tech/html/index.html

Adicione um HTML simples:

<!DOCTYPE html>
<html lang="pt-BR">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Meu Blog de Tecnologia</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            color: white;
        }
        .container {
            text-align: center;
            padding: 40px;
            background: rgba(255, 255, 255, 0.1);
            backdrop-filter: blur(10px);
            border-radius: 20px;
            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
        }
        h1 {
            font-size: 3em;
            margin-bottom: 20px;
            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
        }
        p {
            font-size: 1.2em;
            line-height: 1.6;
            margin-bottom: 30px;
        }
        .badge {
            display: inline-block;
            padding: 10px 20px;
            background: rgba(255, 255, 255, 0.2);
            border-radius: 50px;
            margin: 10px;
            font-size: 0.9em;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>🚀 Servidor no Ar!</h1>
        <p>Bem-vindo ao meu servidor hospedado na Oracle Cloud Free Tier</p>
        <div>
            <span class="badge">Ubuntu 24.04</span>
            <span class="badge">Nginx</span>
            <span class="badge">Ampere ARM</span>
            <span class="badge">Always Free</span>
        </div>
        <p style="margin-top: 30px; font-size: 0.9em; opacity: 0.8;">
            Domínio configurado: <strong>meublog.tech</strong>
        </p>
    </div>
</body>
</html>

Salve o arquivo.

Passo 3.7: Ativando o Site

# Criar symlink para sites-enabled
sudo ln -s /etc/nginx/sites-available/meublog.tech /etc/nginx/sites-enabled/

# Opcional: Desabilitar o site padrão
sudo rm /etc/nginx/sites-enabled/default

# Testar configuração
sudo nginx -t

# Se tudo OK, recarregar Nginx
sudo systemctl reload nginx

Passo 3.8: Testando o Domínio

Abra seu navegador e acesse:

  • http://meublog.tech
  • http://www.meublog.tech

Você deve ver sua página de teste.

Se não funcionar, verifique:

# Ver logs de erro
sudo tail -f /var/log/nginx/error.log

# Ver logs do sistema
sudo journalctl -u nginx -n 50

Parte 4: Configurando SSL/TLS com Let's Encrypt (HTTPS)

Ter HTTPS é essencial hoje em dia. Vamos usar Let's Encrypt, que fornece certificados SSL gratuitos.

Passo 4.1: Instalando o Certbot

# Instalar Certbot e plugin do Nginx
sudo apt install certbot python3-certbot-nginx -y

Passo 4.2: Obtendo o Certificado SSL

sudo certbot --nginx -d meublog.tech -d www.meublog.tech

Durante o processo, você será questionado:

  1. Email: Digite um email válido (para avisos de expiração)
  2. Termos de Serviço: Digite Y para aceitar
  3. Compartilhar email com EFF: Digite N ou Y conforme preferir
  4. Redirect HTTP para HTTPS: Digite 2 para redirecionar todo tráfego para HTTPS

O Certbot irá:

  • Validar que você controla o domínio
  • Obter o certificado SSL
  • Modificar automaticamente sua configuração do Nginx
  • Configurar redirecionamento HTTP → HTTPS

Passo 4.3: Verificando a Instalação

Acesse seu site via HTTPS:

  • https://meublog.tech
  • https://www.meublog.tech

Você deve ver o cadeado verde no navegador indicando conexão segura.

Teste a qualidade do SSL em:

Seu site deve receber nota A ou A+.

Passo 4.4: Renovação Automática

Let's Encrypt emite certificados válidos por 90 dias. O Certbot configura renovação automática:

# Testar renovação
sudo certbot renew --dry-run

# Ver timer de renovação
sudo systemctl status certbot.timer

A renovação automática está configurada para executar duas vezes por dia. Certificados são renovados quando faltam 30 dias para expirar.

Passo 4.5: Configuração Nginx Após SSL

Após o Certbot modificar sua configuração, ela ficará assim:

sudo nano /etc/nginx/sites-available/meublog.tech

server {
    server_name meublog.tech www.meublog.tech;
    
    root /var/www/meublog.tech/html;
    index index.html index.htm index.nginx-debian.html;
    
    access_log /var/log/nginx/meublog.tech.access.log;
    error_log /var/log/nginx/meublog.tech.error.log;
    
    location / {
        try_files $uri $uri/ =404;
    }
    
    location ~ /\.ht {
        deny all;
    }

    listen [::]:443 ssl ipv6only=on; # managed by Certbot
    listen 443 ssl; # managed by Certbot
    ssl_certificate /etc/letsencrypt/live/meublog.tech/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/meublog.tech/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}

server {
    if ($host = www.meublog.tech) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

    if ($host = meublog.tech) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

    listen 80;
    listen [::]:80;
    
    server_name meublog.tech www.meublog.tech;
    return 404; # managed by Certbot
}

Passo 4.6: Melhorando a Configuração SSL (Opcional)

Para segurança adicional, você pode fortalecer a configuração SSL:

sudo nano /etc/nginx/sites-available/meublog.tech

Adicione dentro do bloco server que escuta na porta 443:

    # Segurança adicional SSL
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384;
    ssl_session_timeout 10m;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    
    # Headers de segurança
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Referrer-Policy "no-referrer-when-downgrade" always;

Teste e recarregue:

sudo nginx -t
sudo systemctl reload nginx

Parte 5: Configurações Avançadas e Otimizações

Passo 9.1: Configurando Compressão Gzip Avançada

Já configuramos o básico, mas vamos otimizar:

sudo nano /etc/nginx/nginx.conf

Na seção http {, melhore as configurações gzip:

    ##
    # Gzip Settings
    ##
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_buffers 16 8k;
    gzip_http_version 1.1;
    gzip_min_length 256;
    gzip_types
        application/atom+xml
        application/geo+json
        application/javascript
        application/x-javascript
        application/json
        application/ld+json
        application/manifest+json
        application/rdf+xml
        application/rss+xml
        application/xhtml+xml
        application/xml
        font/eot
        font/otf
        font/ttf
        image/svg+xml
        text/css
        text/javascript
        text/plain
        text/xml;

Passo 5.2: Configurando Cache de Arquivos Estáticos

No arquivo do seu site:

sudo nano /etc/nginx/sites-available/meublog.tech

Adicione locations para cache:

    # Cache de imagens
    location ~* \.(jpg|jpeg|png|gif|ico|svg)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
        access_log off;
    }
    
    # Cache de CSS e JavaScript
    location ~* \.(css|js)$ {
        expires 1y;
        add_header Cache-Control "public";
        access_log off;
    }
    
    # Cache de fontes
    location ~* \.(woff|woff2|ttf|otf|eot)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
        access_log off;
    }

Passo 5.3: Configurando Logs Rotacionados

O logrotate já está instalado, mas vamos verificar a configuração:

sudo nano /etc/logrotate.d/nginx

Deve conter algo assim:

/var/log/nginx/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 www-data adm
    sharedscripts
    prerotate
        if [ -d /etc/logrotate.d/httpd-prerotate ]; then \
            run-parts /etc/logrotate.d/httpd-prerotate; \
        fi
    endscript
    postrotate
        invoke-rc.d nginx rotate >/dev/null 2>&1
    endscript
}

Passo 5.4: Monitoramento com Netdata (Opcional)

Netdata é uma ferramenta excelente de monitoramento em tempo real:

# Instalar Netdata
bash <(curl -Ss https://my-netdata.io/kickstart.sh)

Durante a instalação, aceite as opções padrão.

Após a instalação, Netdata estará rodando na porta 19999. Para acessar:

Opção 1: Configurar proxy reverso no Nginx:

sudo nano /etc/nginx/sites-available/meublog.tech

Adicione um novo location:

    location /netdata {
        return 301 /netdata/;
    }
    
    location ~ /netdata/(?<ndpath>.*) {
        proxy_redirect off;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Server $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_http_version 1.1;
        proxy_pass_request_headers on;
        proxy_set_header Connection "keep-alive";
        proxy_store off;
        proxy_pass http://localhost:19999/$ndpath$is_args$args;
        
        gzip on;
        gzip_proxied any;
        gzip_types *;
    }

Agora você pode acessar em https://meublog.tech/netdata/

Opção 2: Abrir a porta 19999 temporariamente quando precisar:

sudo ufw allow 19999/tcp

Acesse via http://SEU_IP:19999 e depois feche:

sudo ufw delete allow 19999/tcp

Passo 5.5: Configurando Backups Automáticos

Criar script de backup:

sudo nano /usr/local/bin/backup-website.sh

Conteúdo:

#!/bin/bash

# Configurações
BACKUP_DIR="/home/ubuntu/backups"
WEBSITE_DIR="/var/www/meublog.tech"
NGINX_CONF="/etc/nginx/sites-available/meublog.tech"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="website_backup_$DATE.tar.gz"

# Criar diretório de backup se não existir
mkdir -p $BACKUP_DIR

# Criar backup
tar -czf $BACKUP_DIR/$BACKUP_NAME \
    $WEBSITE_DIR \
    $NGINX_CONF \
    /etc/letsencrypt

# Manter apenas últimos 7 backups
cd $BACKUP_DIR
ls -t | tail -n +8 | xargs -r rm

echo "Backup criado: $BACKUP_NAME"

Tornar executável:

sudo chmod +x /usr/local/bin/backup-website.sh

Agendar com cron:

crontab -e

Adicione (backup diário às 3h da manhã):

0 3 * * * /usr/local/bin/backup-website.sh >> /home/ubuntu/backups/backup.log 2>&1

Testar:

/usr/local/bin/backup-website.sh
ls -lh ~/backups/

Parte 6: Implantando uma Aplicação Real

Vamos implantar exemplos de aplicações comuns.

Exemplo 1: Site Estático (Hugo, Jekyll, Next.js static)

Se você tem um site estático gerado:

# Fazer upload via SCP (do seu computador)
scp -r -i sua-chave.key ./public ubuntu@SEU_IP:/tmp/

# No servidor
sudo rm -rf /var/www/meublog.tech/html/*
sudo cp -r /tmp/public/* /var/www/meublog.tech/html/
sudo chown -R www-data:www-data /var/www/meublog.tech/html

Obs.: Em um próximo post, vou trazer um tutorial de como instalar e configurar o Runtipi para instalar o Ghost (a plataforma a qual estou utilizando em meu site).

Exemplo 2: Aplicação Node.js com PM2

Instalar Node.js:

# Instalar NVM (Node Version Manager)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash

# Recarregar shell
source ~/.bashrc

# Instalar Node.js LTS
nvm install --lts
nvm use --lts

# Verificar
node --version
npm --version

Instalar PM2 (gerenciador de processos):

npm install -g pm2

Clonar ou fazer upload da sua aplicação:

cd /var/www
sudo mkdir -p meublog-app
sudo chown $USER:$USER meublog-app
cd meublog-app

# Exemplo: clonar repositório
git clone https://github.com/seu-usuario/seu-app.git .

# Instalar dependências
npm install

Configurar variáveis de ambiente:

nano .env

Adicione suas variáveis:

PORT=3000
NODE_ENV=production
DATABASE_URL=sua_connection_string

Iniciar com PM2:

pm2 start npm --name "meublog-app" -- start
# ou
pm2 start app.js --name "meublog-app"

# Configurar para iniciar no boot
pm2 startup systemd
# Execute o comando que o PM2 mostrar

pm2 save

Configurar Nginx como proxy reverso:

sudo nano /etc/nginx/sites-available/meublog.tech

Modificar o location /:

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

Recarregar Nginx:

sudo nginx -t
sudo systemctl reload nginx

Comandos úteis do PM2:

pm2 list                  # Listar processos
pm2 logs meublog-app     # Ver logs
pm2 restart meublog-app  # Reiniciar
pm2 stop meublog-app     # Parar
pm2 delete meublog-app   # Remover
pm2 monit                # Monitor em tempo real

Exemplo 3: WordPress com MySQL

Instalar MySQL:

sudo apt install mysql-server -y

# Configurar segurança
sudo mysql_secure_installation

Responda às perguntas:

  • VALIDATE PASSWORD COMPONENT: Y
  • Password validation policy: 2 (STRONG)
  • New password: [crie uma senha forte]
  • Remove anonymous users: Y
  • Disallow root login remotely: Y
  • Remove test database: Y
  • Reload privilege tables: Y

Criar banco de dados para WordPress:

sudo mysql

No prompt MySQL:

CREATE DATABASE wordpress DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'wordpressuser'@'localhost' IDENTIFIED BY 'senha_forte_aqui';
GRANT ALL ON wordpress.* TO 'wordpressuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Instalar PHP:

sudo apt install php-fpm php-mysql php-curl php-gd php-intl \
    php-mbstring php-soap php-xml php-xmlrpc php-zip -y

Configurar PHP:

sudo nano /etc/php/8.1/fpm/php.ini

Modificar:

upload_max_filesize = 64M
post_max_size = 64M
memory_limit = 256M
max_execution_time = 300

Reiniciar PHP-FPM:

sudo systemctl restart php8.1-fpm

Baixar WordPress:

cd /tmp
curl -O https://wordpress.org/latest.tar.gz
tar xzvf latest.tar.gz

sudo cp -a /tmp/wordpress/. /var/www/meublog.tech/html/
sudo chown -R www-data:www-data /var/www/meublog.tech/html

Configurar Nginx para PHP:

sudo nano /etc/nginx/sites-available/meublog.tech

Modificar a configuração:

server {
    server_name meublog.tech www.meublog.tech;
    
    root /var/www/meublog.tech/html;
    index index.php index.html index.htm;
    
    access_log /var/log/nginx/meublog.tech.access.log;
    error_log /var/log/nginx/meublog.tech.error.log;
    
    location / {
        try_files $uri $uri/ /index.php?$args;
    }
    
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
    
    location ~ /\.ht {
        deny all;
    }
    
    location = /favicon.ico {
        log_not_found off;
        access_log off;
    }
    
    location = /robots.txt {
        log_not_found off;
        access_log off;
        allow all;
    }
    
    location ~* \.(css|gif|ico|jpeg|jpg|js|png)$ {
        expires max;
        log_not_found off;
    }

    listen 443 ssl;
    ssl_certificate /etc/letsencrypt/live/meublog.tech/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/meublog.tech/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}

server {
    if ($host = www.meublog.tech) {
        return 301 https://$host$request_uri;
    }
    
    if ($host = meublog.tech) {
        return 301 https://$host$request_uri;
    }
    
    listen 80;
    server_name meublog.tech www.meublog.tech;
    return 404;
}

Testar e recarregar:

sudo nginx -t
sudo systemctl reload nginx

Acessar WordPress:

  • Vá para https://meublog.tech
  • Siga o instalador do WordPress
  • Use as credenciais do banco de dados criadas anteriormente

Parte 7: Manutenção e Monitoramento

Passo 7.1: Comandos de Monitoramento Essenciais

# Ver uso de CPU e memória
htop

# Ver uso de disco
df -h

# Ver uso de rede
sudo iftop

# Ver processos do Nginx
ps aux | grep nginx

# Ver processos do PHP
ps aux | grep php

# Ver conexões ativas
sudo netstat -tupln

# Ver logs em tempo real
sudo tail -f /var/log/nginx/access.log
sudo tail -f /var/log/nginx/error.log

Passo 7.2: Atualizações de Segurança

Configure atualizações automáticas de segurança:

sudo apt install unattended-upgrades -y
sudo dpkg-reconfigure --priority=low unattended-upgrades

Selecione "Yes" para habilitar.

Verificar atualizações manualmente:

sudo apt update
sudo apt list --upgradable
sudo apt upgrade -y

Passo 7.3: Verificação de Integridade Regular

Criar script de verificação:

nano ~/check-health.sh

Conteúdo:

#!/bin/bash

echo "========== System Health Check =========="
echo "Date: $(date)"
echo ""

echo "=== Disk Usage ==="
df -h | grep -E '^/dev'
echo ""

echo "=== Memory Usage ==="
free -h
echo ""

echo "=== Top Processes by CPU ==="
ps aux --sort=-%cpu | head -6
echo ""

echo "=== Top Processes by Memory ==="
ps aux --sort=-%mem | head -6
echo ""

echo "=== Nginx Status ==="
sudo systemctl status nginx --no-pager | head -5
echo ""

echo "=== SSL Certificate Expiry ==="
sudo certbot certificates
echo ""

echo "=== Failed Login Attempts (last 10) ==="
sudo grep "Failed password" /var/log/auth.log | tail -10
echo ""

Tornar executável:

chmod +x ~/check-health.sh

Executar:

./check-health.sh

Passo 7.4: Backup para Object Storage da Oracle (Opcional)

A Oracle Cloud oferece 10 GB de Object Storage gratuito. Você pode usá-lo para backups:

Instalar OCI CLI:

bash -c "$(curl -L https://raw.githubusercontent.com/oracle/oci-cli/master/scripts/install/install.sh)"

# Adicionar ao PATH
echo 'export PATH=$PATH:/home/ubuntu/bin' >> ~/.bashrc
source ~/.bashrc

Configurar:

oci setup config

Você precisará das informações do seu tenancy da Oracle Cloud (veja na página de perfil).

Criar bucket:

oci os bucket create --name backups --compartment-id ocid1.compartment.oc1..xxx

Script de backup para Object Storage:

nano ~/backup-to-oci.sh

#!/bin/bash

BACKUP_DIR="/home/ubuntu/backups"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="website_backup_$DATE.tar.gz"

# Criar backup
/usr/local/bin/backup-website.sh

# Upload para OCI
oci os object put \
    --bucket-name backups \
    --file $BACKUP_DIR/$BACKUP_NAME \
    --name $BACKUP_NAME

echo "Backup uploaded to OCI: $BACKUP_NAME"

Conclusão

Parabéns! Você agora tem um servidor completo rodando na Oracle Cloud Free Tier com:

✅ Ubuntu 24.04 LTS otimizado
✅ Nginx configurado e seguro
✅ SSL/TLS com Let's Encrypt
✅ Domínio personalizado configurado
✅ Firewall configurado (UFW + iptables + Oracle Security Lists)
✅ Proteção contra força bruta (Fail2Ban)
✅ Monitoramento básico
✅ Backups automáticos
✅ Pronto para hospedar aplicações web

Este servidor pode rodar:

  • Sites estáticos
  • WordPress
  • Aplicações Node.js, Python, Ruby, Go
  • APIs REST
  • Bancos de dados
  • Containers Docker
  • E muito mais!

Próximos Passos Sugeridos

  1. CDN: Configurar Cloudflare na frente para cache e proteção DDoS
  2. CI/CD: Automatizar deploys com GitHub Actions
  3. Docker: Containerizar suas aplicações
  4. Kubernetes: Para projetos maiores, usar K3s
  5. Observabilidade: Integrar com ferramentas como Prometheus + Grafana
  6. WAF: Configurar Web Application Firewall
  7. Database: Usar o Autonomous Database gratuito da Oracle
  8. Email: Configurar servidor de email ou usar serviços como SendGrid

Recursos Adicionais

Custos

Tudo descrito neste guia está dentro do Always Free Tier da Oracle Cloud, ou seja:

  • Custo mensal: R$ 0,00
  • Único custo: Domínio (cerca de R$ 40-80/ano dependendo do registrador)

Importante Lembrar

  1. Mantenha seu sistema sempre atualizado
  2. Monitore recursos para não ultrapassar limites do Free Tier
  3. Faça backups regulares
  4. Use senhas fortes
  5. Mantenha apenas as portas necessárias abertas
  6. Revise logs regularmente
  7. Configure alertas para uso de recursos

Este servidor pode atender facilmente sites com milhares de visitantes por dia, sendo uma excelente opção para blogs pessoais, portfólios, APIs, ambientes de desenvolvimento e muito mais.

Se este guia foi útil, compartilhe com outros desenvolvedores! 🚀

Published by:

Renan

You might also like...

02
Fev

Guia Completo: Criando um Servidor na Oracle Cloud Free Tier

9 min read
Mastodon