Deploy de Alta Performance com Laravel Octane no Locaweb Cloud

1. Pré-requisitos

Para garantir a eficiência técnica e colocar seu projeto no ar rapidamente, valide os seguintes requisitos antes de iniciar as configurações:

• Conta ativa no painel do Locaweb Cloud (Apache CloudStack).
• Duas Máquinas Virtuais (VMs) em execução com Ubuntu 22.04 LTS na mesma rede VPC.
• Uma terceira VM (ou Tier dedicada) isolada para o banco de dados.
• Chave privada SSH (.key ou .pem) configurada localmente com permissão restrita (chmod 400).
• Um domínio de site registrado e pronto para ser apontado para o IP público do projeto.

Está com dúvidas sobre como começar no Locaweb Cloud? Acesse nosso tutorial de apoio. 

2. Configuração de infraestrutura (painel)

Prepare toda a infraestrutura de rede na borda do painel antes de tocar no terminal de comandos. O tráfego só será distribuído corretamente se as regras de balanceamento e segurança estiverem ativas.

Passo 1: Alocação de IP Público

1. Acesse o painel do Locaweb Cloud, navegue até Rede > VPC e clique no nome da sua rede.
2. Acesse a aba Endereços IP Públicos e clique em Obter um novo IP. Esse endereço será o ponto central de acesso da sua aplicação.

Passo 2: Configuração do Balanceamento de Carga

[Aviso!] Um endereço IP configurado com Balanceamento de Carga não pode utilizar NAT Estático simultaneamente. Certifique-se de manter essa opção desmarcada.

Acesse a aba Balanceamento de Carga do IP alocado e configure as regras de entrada:

1. Regra Principal (HTTPS):
   • Nome: LB-Octane-HTTPS
   • Porta Pública / Privada: 443 (a terminação SSL será feita pelo Nginx de cada VM).
   • Algoritmo: Selecione Round-Robin ou Least Connections.
   • Protocolo: TCP. Vincule as duas instâncias de aplicação a esta regra.
2. Regra Auxiliar (HTTP):
   • Nome: LB-Octane-HTTP
   • Porta Pública / Privada: 80 (necessário para a validação do Certbot e redirecionamento de tráfego).

Passo 3: Port Forwarding para acesso SSH (Administração)

Para administrar suas instâncias de forma segura sem expor a porta padrão diretamente à internet, acesse a aba Encaminhamento de Portas (Port Forwarding) e mapeie portas públicas distintas para a porta privada 22 de cada máquina:

VM de Destino	Protocolo	Porta Pública	Porta Privada	Finalidade
Instância de Aplicação 1	TCP	2201	22	Acesso SSH à VM 1
Instância de Aplicação 2	TCP	2202	22	Acesso SSH à VM 2

 

Passo 4: Liberação de Portas no Firewall

Acesse a aba Firewall do IP público e autorize a entrada de tráfego aplicando as seguintes regras:

Origem (CIDR)	Porta	Protocolo	Finalidade
0.0.0.0/0	80	TCP	Tráfego HTTP público
0.0.0.0/0	443	TCP	Tráfego HTTPS público
<SEU_IP_DE_ADMIN>/32	2201	TCP	SSH administrativo restrito da VM 1
<SEU_IP_DE_ADMIN>/32	2202	TCP	SSH administrativo restrito da VM 2

 

3. Configuração de sistema (Terminal)

Realize os passos de preparação do ambiente operacional em todas as instâncias de aplicação vinculadas ao balanceador. Acesse a primeira VM utilizando a porta mapeada no passo anterior:

Bash

ssh -i /caminho/sua-chave.key -p 2201 ubuntu@<SEU_IP_PUBLICO>

 

3.1. Instalação de Dependências e PHP

Sincronize os índices de pacotes locais e instale o interpretador do PHP 8.2 e o servidor web Nginx:

Bash

# Atualiza os índices do sistema operacional e aplica correções

sudo apt update && sudo apt upgrade -y




# Instala o Nginx, PHP CLI, runtime do Swoole e dependências do Laravel

sudo apt install -y nginx php8.2-cli php8.2-fpm php8.2-swoole php8.2-mysql php8.2-mbstring php8.2-xml php8.2-curl php8.2-bcmath unzip git

Baixe o utilitário oficial do Composer e mova o binário para o PATH de execução do sistema:

Bash

curl -sS https://getcomposer.org/installer | php

sudo mv composer.phar /usr/local/bin/composer

4. Configuração do banco de dados: PostgreSQL / MySQL

Para garantir o isolamento e eliminar o caos de operações fragmentadas, o banco de dados deve rodar em uma VM dedicada dentro da sub-rede privada da VPC (ex.: IP 10.1.1.10), aceitando conexões apenas da sub-rede das aplicações (10.1.2.0/24).

Passo 1: Instalação e Hardening do MySQL

Acesse o terminal do seu servidor dedicado de banco de dados e instale o serviço:

Bash

sudo apt update && sudo apt install -y mysql-server

sudo systemctl enable --now mysql




# Dispara o assistente interativo de segurança e remoção de acessos anônimos

sudo mysql_secure_installation

 

Passo 2: Configurar acesso na rede privada

Abra o arquivo de parametrização do MySQL para ajustar o endereço de escuta, impedindo que a porta responda à internet aberta:

Bash

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Configure a linha de monitoramento apontando exclusivamente para o IP privado da própria instância de banco:

Ini, TOML

bind-address = 10.1.1.10




Bash

sudo systemctl restart mysql

 

Passo 3: Criar credenciais de produção

Abra o console do banco e crie o usuário restringindo os privilégios de acesso ao barramento da sub-rede de aplicação:

Bash

sudo mysql

 

SQL

-- Comandos executados no terminal administrativo do MySQL

CREATE DATABASE octane_app CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;




-- Cria o usuário amarrado estritamente ao CIDR privado das instâncias web

CREATE USER 'octane_user'@'10.1.2.%' IDENTIFIED BY 'TROQUE_POR_UMA_SENHA_FORTE';

GRANT ALL PRIVILEGES ON octane_app.* TO 'octane_user'@'10.1.2.%';

FLUSH PRIVILEGES;

EXIT;

5. Deploy da aplicação

Método 1 (Recomendado): Docker + GitHub Actions

A conteinerização garante um ambiente reprodutível e acelera o seu time-to-market. Instale o Docker nas instâncias web através do repositório oficial assinado (nunca utilize scripts genéricos em produção):

Bash

sudo apt-get update && sudo apt-get install -y ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg




echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null




sudo apt-get update && sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

sudo systemctl enable --now docker && sudo usermod -aG docker $USER

Salve o Dockerfile na raiz do seu projeto local configurado para rodar com Swoole na porta interna 8000:

Dockerfile

FROM php:8.2-cli

RUN apt-get update && apt-get install -y libzip-dev unzip git \

    && docker-php-ext-install pdo_mysql bcmath \

    && pecl install swoole && docker-php-ext-enable swoole

COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

WORKDIR /app

COPY . /app

RUN composer install --no-dev --optimize-autoloader

EXPOSE 8000

CMD ["php", "artisan", "octane:start", "--server=swoole", "--host=0.0.0.0", "--port=8000", "--workers=4", "--max-requests=1000"]

 

Ative a esteira automatizada salvando o workflow .github/workflows/deploy.yml no seu GitHub, alimentando os Secrets (SSH_HOST, SSH_PORT, SSH_USER, SSH_KEY) para realizar o deploy em formato autosserviço (PLG) a cada push na branch main.

Método 2: Deploy manual

Caso opte por rodar direto na máquina, clone o projeto no diretório /var/www/html/aplicacao, rode o comando composer install –no-dev –optimize-autoloader e configure a inicialização contínua criando um serviço do systemd:

Bash

sudo nano /etc/systemd/system/octane.service

 

Ini, TOML

[Unit]

Description=Laravel Octane Server

After=network.target




[Service]

Type=simple

User=www-data

Group=www-data

WorkingDirectory=/var/www/html/aplicacao

ExecStart=/usr/bin/php artisan octane:start --server=swoole --host=127.0.0.1 --port=8000 --workers=4 --task-workers=4 --max-requests=1000

Restart=always

RestartSec=5




[Install]

WantedBy=multi-user.target

Bash

sudo systemctl daemon-reload && sudo systemctl enable --now octane

 

6. Configuração do Nginx (Proxy Reverso) e HTTPS

O Nginx receberá as conexões repassadas pela borda da infraestrutura e encaminhará o tráfego interno para o processo Octane rodando na memória.

Passo 1: Configurar Proxy Reverso

Crie o arquivo de configuração do site no diretório do Nginx:

Bash

sudo nano /etc/nginx/sites-available/octane.conf

Nginx

server {

    listen 80;

    server_name seu-dominio.com.br www.seu-dominio.com.br;




    location / {

        proxy_pass http://127.0.0.1:8000;

        proxy_set_header Host $http_host;

        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;

        proxy_http_version 1.1;

        proxy_set_header Upgrade $http_upgrade;

        proxy_set_header Connection "upgrade";

    }




    # Cache e entrega direta de estáticos via Nginx para poupar a RAM da aplicação

    location ~* \.(jpg|jpeg|gif|png|css|js|ico|webp|svg|woff2)$ {

        root /var/www/html/aplicacao/public;

        expires max;

        access_log off;

    }

}

Bash

sudo ln -s /etc/nginx/sites-available/octane.conf /etc/nginx/sites-enabled/

sudo nginx -t && sudo systemctl reload nginx

Passo 2: Terminação SSL com Let’s Encrypt

Como o balanceador de carga encaminha as requisições da porta 443 TCP diretamente para as instâncias, emita o certificado SSL na ponta de cada máquina:

Bash

sudo apt install -y certbot python3-certbot-nginx

sudo certbot --nginx -d seu-dominio.com.br -d www.seu-dominio.com.br

 

7. Validação

Verificação de Residente em Memória

Valide localmente nas VMs se o container do Docker ou o serviço do systemd estão ativos e escutando a porta interna correta:

Bash

# Para deploys manuais:

sudo systemctl status octane


# Para deploys via Docker:

docker ps


# Testa a resposta local da aplicação (Deve retornar HTTP 200 OK)

curl -I http://127.0.0.1:8000

Teste externo e isolamento

A partir do prompt do seu computador de desenvolvimento local, envie requisições externas para testar a topologia e certificar-se do isolamento completo do banco:

Bash

# Valida a entrega final criptografada via Load Balancer e Nginx

curl -I https://seu-dominio.com.br



# Deve falhar por timeout, atestando o isolamento da porta 3306 na internet

nc -zv <SEU_IP_PUBLICO> 3306

8. Solução de problemas (Troubleshooting)

• Erro 502 Bad Gateway ao carregar o domínio: O Nginx está ativo, mas o motor do Octane na porta 8000 caiu ou falhou no boot. Analise as falhas de código inspecionando o log de inicialização com sudo journalctl -u octane -n 50 –no-pager.
• Conexão administrativa SSH sofrendo quedas por timeout: Certifique-se de realizar o acesso informando a porta pública correta configurada no seu Port Forwarding (-p 2201 ou -p 2202) e valide se o seu IP atual não mudou na regra de Firewall.
• Mensagens de erro SQLSTATE[HY000] [2002] Connection refused: Indica que as instâncias web não alcançam a base de dados. Revise se o bind-address do arquivo mysqld.cnf na VM de banco está salvo com o IP privado correto e confira as regras de ACL na VPC.