In this tutorial, I'll walk you through the complete installation of Coolify on an Ubuntu 24.04 LTS server.

Sign up for DigitalOcean using my link and get \(200 for your projects, valid for 60 days! Click here: GET \)200

Prerequisites

Before we begin, make sure you have:

• A server (VPS or dedicated) running Ubuntu 24.04 LTS

• Root access or a user with sudo privileges

• At least 2 vCPUs, 2 GB RAM, and 30 GB of storage

• A domain name pointed to your server's IP (optional, but recommended)

Required Ports

Updating the Operating System

Step 1 - Update the operating system.

sudo apt update && sudo apt upgrade -y

Step 2 - Install the required dependencies.

sudo apt install -y curl wget git

Configuring the Firewall

Step 3 - If you're using UFW (Ubuntu's default firewall), allow the required ports:

sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 8000/tcp
sudo ufw allow 6001/tcp
sudo ufw allow 6002/tcp

Step 4 - Enable the firewall if it isn't already:

sudo ufw enable

Step 5 - Verify the rules:

sudo ufw status

You should see all the ports listed as ALLOW.

Coolify Installation

Step 6 - Run the automated installation script as root:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

⚠️ If you're not logged in as root, use sudo:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

The script will:

1. Check your system requirements

2. Install Docker Engine and Docker Compose (if not already installed)

3. Download and configure Coolify

4. Start all required containers

This process may take a few minutes depending on your server's internet speed. Once completed, you'll see a success message with the URL to access Coolify.

Accessing the Dashboard

Step 7 - Open your browser and navigate to:

http://YOUR_SERVER_IP:8000

Replace YOUR_SERVER_IP with your server's actual IP address.

Step 8 - Create your admin account by setting a strong email and password.

Step 9 - Coolify will automatically detect your localhost server. Confirm the server configuration and you're ready to go!

Setting Up a Custom Domain (Optional)

Step 10 - Add an A record in your DNS provider pointing to your server's IP:

Step 11 - Log in to the Coolify dashboard, go to Settings → General and set your Instance's Domain to https://coolify.yourdomain.com.

Coolify will automatically generate a Let's Encrypt SSL certificate for your domain.

Deploying Your First Application

Step 12 - On the dashboard, click "New Resource".

Step 13 - Select "Public Repository" and paste a Git repository URL (e.g., https://github.com/coollabsio/coolify-examples).

Step 14 - Choose the branch, build pack, and target server, then click Deploy.

Coolify will clone the repository, build the application, and deploy it automatically.

Enabling Auto-Updates

Step 15 - Go to Settings → General and toggle "Auto Update" to enabled.

This ensures you always have the latest features and security patches without manual intervention.

Useful Commands

Check running containers:

docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

View Coolify logs:

docker logs -f coolify

Restart Coolify:

docker restart coolify coolify-realtime coolify-db coolify-redis

Stop Coolify:

docker compose -f /data/coolify/docker-compose.yml stop

Start Coolify:

docker compose -f /data/coolify/docker-compose.yml up -d

Troubleshooting

If port 8000 is not accessible, make sure the firewall allows traffic and reload:

sudo ufw allow 8000/tcp
sudo ufw reload

⚠️ If you're using a cloud provider (AWS, DigitalOcean, Hetzner), also check the Security Groups or Firewall Rules in the provider's dashboard.

If you encounter Docker permission errors, add your user to the Docker group:

sudo usermod -aG docker $USER
newgrp docker

If the installation script fails, run it with verbose output to identify the issue:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash -x

Did I help you?

Buy me a beer! 🍺😁

Update packages and install PostgreSQL server:

sudo apt update && sudo apt upgrade -y

Install PostgreSQL server

sudo apt install postgresql postgresql-contrib -y

Check if the service is active:

sudo systemctl status postgresql

📌 2. Create a new database and change user password

Switch to the administrative postgres user:

sudo -i -u postgres

Open the PostgreSQL prompt:

psql

Now execute the SQL commands:

-- Create database
CREATE DATABASE n8n_db;

-- Change postgres user password
ALTER USER postgres PASSWORD 'your_new_password';


-- Grant permissions to the user on the database
GRANT ALL PRIVILEGES ON DATABASE n8n_db TO postgres;

This tutorial is available as a video on YouTube: https://www.youtube.com/watch?v=KZh9Wodsa40

Updating the Operating System

Step 1 - Update the operating system.

sudo apt update && sudo apt upgrade -y

Installing Node and NPM

On the official Node.js website, you can download the latest binaries as shown in the figure below. As of this writing, the LTS (long time support) version is 22.22.0. We'll use it in this tutorial.

Step 2 - Use the command below in your terminal to download the binaries.

curl -o node.tar.xz https://nodejs.org/dist/v22.22.0/node-v22.22.0-linux-x64.tar.xz

Step 3 - Use the command below to extract the package and enter the folder.

tar -xf node.tar.xz && cd node-v22.22.0-linux-x64

Step 4 - With the command below, we'll copy the files to make them available globally.

sudo cp -R * /usr/local/

Done! After this, Node should be available for use. Run the commands below to verify.

node -v && npm -v && cd ..

If everything is correct, you should see something like shown in the figure.

PostgreSQL Installation

Step 5 - Install PostgreSQL

sudo apt install postgresql postgresql-contrib -y

Step 6 - Check if the service is active:

sudo systemctl status postgresql

Step 7 - Switch to the administrative postgres user:

sudo -i -u postgres

Step 8 - Open the PostgreSQL prompt:

psql

Step 9 - Now execute the SQL commands:

⚠️ Don't forget to replace with your own secure password.

-- Create a new user
CREATE ROLE n8n_user WITH LOGIN PASSWORD 'put-your-super-strong-password-here';

-- Create database
CREATE DATABASE n8n_db OWNER n8n_user;

-- Grant permissions to the user on the database
GRANT ALL PRIVILEGES ON DATABASE n8n_db TO n8n_user;
GRANT ALL ON SCHEMA public TO n8n_user;
ALTER SCHEMA public OWNER TO n8n_user;

Step 10 - Now disconnect from the database

\q

Step 11 - Disconnect from the postgres user

exit

N8N Installation

Step 12 - Install N8N

npm install n8n -g

Step 13 - Create a specific user for n8n:

sudo adduser --system --group --home /home/n8n n8n

Step 14 - Configure the directory where n8n will store files and credentials.

sudo mkdir -p /home/n8n/.n8n
sudo chown -R n8n:n8n /home/n8n/.n8n

Step 15 - Generate a new encryption key with the command below, we'll use it next.

openssl rand -base64 48

Step 16 - Create a .env file for the service (centralizes configs and makes it easy to maintain):

sudo nano /home/n8n/.n8n/.env

Step 17 - Copy the content below into the .env file you just created.

# ===== Core =====
N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
N8N_USER_FOLDER=/home/n8n/.n8n
N8N_HOST=YOUR-SERVER-IP
N8N_PORT=5678
# If exposing publicly, define BASE_URL (https://your-domain):
# N8N_EDITOR_BASE_URL=https://your-domain
# WEBHOOK_URL=https://your-domain/
N8N_RUNNERS_ENABLED=true
N8N_SECURE_COOKIE=false
# ===== Database (Postgres) =====
DB_TYPE=postgresdb
DB_POSTGRESDB_HOST=127.0.0.1
DB_POSTGRESDB_PORT=5432
DB_POSTGRESDB_DATABASE=n8n_db
DB_POSTGRESDB_USER=n8n_user
DB_POSTGRESDB_PASSWORD=put-your-super-strong-password-here
# Pool (optional, improves stability)
DB_POSTGRESDB_POOL_SIZE=10

# ===== Security (adjust according to your scenario) =====
# Basic Auth for editor
#N8N_BASIC_AUTH_ACTIVE=true
#N8N_BASIC_AUTH_USER=admin
#N8N_BASIC_AUTH_PASSWORD=another-super-strong-password

# Encryption key for credentials
N8N_ENCRYPTION_KEY=PUT-HERE-THE-ENCRYPTION-KEY-YOU-GENERATED

# ===== Queues (optional) - if using queues with Redis =====
# QUEUE_BULL_REDIS_HOST=127.0.0.1
# QUEUE_BULL_REDIS_PORT=6379

Step 18 - Apply restrictive permissions:

sudo chmod 600 /home/n8n/.n8n/.env

Step 19 - Create the service file to run n8n with systemd.
This ensures that n8n is started automatically with the server and is monitored.

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

Step 20 - Copy the content below to the file you just created.

[Unit]
Description=n8n Automation (Workflow) Service
After=network-online.target postgresql.service
Wants=network-online.target

[Service]
# Dedicated user
User=n8n
Group=n8n
EnvironmentFile=/home/n8n/.n8n/.env
WorkingDirectory=/home/n8n

# App startup
ExecStart=/usr/local/bin/n8n start
Restart=always
RestartSec=5

# Limits and robustness
LimitNOFILE=65535

# Logs to journal (journalctl)
StandardOutput=journal
StandardError=journal

# Hardening (adjust if you need access outside home)
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full
ProtectHome=read-only
ReadWritePaths=/home/n8n /tmp /var/tmp

# If n8n needs to bind ports <1024, remove the line below
CapabilityBoundingSet=
AmbientCapabilities=

# Longer timeout for initial migrations
TimeoutStartSec=120

[Install]
WantedBy=multi-user.target

Step 21 - Reload systemd, enable the n8n service at startup and start it immediately.

sudo systemctl daemon-reload
sudo systemctl enable n8n
sudo systemctl start n8n

Step 22 - Check if the service is running correctly.

systemctl status n8n
journalctl -u n8n -f

Troubleshooting

If you see a migration/permission error in Postgres, run a manual test:

sudo -u n8n env $(cat /home/n8n/.n8n/.env | xargs) n8n start

This way you can see errors with the same variables as the service.

Did I help you?

Buy me a beer! 🍺😁

PIX QrCode

Este tutorial esta disponível em vídeo no YouTube: https://www.youtube.com/watch?v=KZh9Wodsa40

Atualizando o sistema operacional

1º Passo - Atualize o sistema operacional.

sudo apt update && sudo apt upgrade -y

Instalação do Node e NPM

No site oficial do node.js você pode baixar os binários mais recentes como mostra a figura abaixo. Na data que escrevo, a versão LTS(long time support) é a 22.19.0. Usaremos ela neste tutorial.

2º Passo - Use o comando abaixo no seu terminal para baixar os binários.

curl -o node.tar.xz https://nodejs.org/dist/v22.19.0/node-v22.19.0-linux-x64.tar.xz

3º Passo - Use o comando abaixo para descompatar o pacote e entrar na pasta.

tar -xf node.tar.xz && cd node-v22.19.0-linux-x64

4º Passo - Com o comando abaixo, vamos copiar os arquivos para que fiquem disponíveis globalmente.

sudo cp -R * /usr/local/

Pronto! Feito isso o noje deve estar disponível para uso. Execute os comandos abaixo para verificar.

node -v && npm -v && cd ..

Se tudo estiver correto, você deve ver algo como mostrado na figura.

Instalação do PostgresSQL

5º Passo - Instale o PostgreSQL

sudo apt install postgresql postgresql-contrib -y

6º Passo - Verifique se o serviço está ativo:

sudo systemctl status postgresql

7º Passo - Entre no usuário administrativo postgres:

sudo -i -u postgres

8º Passo - Abra o prompt do PostgreSQL:

psql

9º Passo - Agora execute os comandos SQL:

⚠️ Não esqueça de trocar pela sua própria senha segura.

-- Criar um novo usuario
CREATE ROLE n8n_user WITH LOGIN PASSWORD 'coloque-sua-senha-super-forte-aqui';

-- Criar banco de dados
CREATE DATABASE n8n_db OWNER n8n_user;

-- Dar permissões ao usuário no banco
GRANT ALL PRIVILEGES ON DATABASE n8n_db TO n8n_user;
GRANT ALL ON SCHEMA public TO n8n_user;
ALTER SCHEMA public OWNER TO n8n_user;

10º Passo - Agora desconecte do banco

\q

11º Passo - Desconecte do usuário postgres

exit

Instalação do N8N

12º Passo -Instale o N8N

npm install n8n -g

13º Passo - Crie um usuário específico para o n8n:

sudo adduser --system --group --home /home/n8n n8n

14º Passo - Configure o diretório onde o n8n armazenará arquivos e credenciais.

sudo mkdir -p /home/n8n/.n8n
sudo chown -R n8n:n8n /home/n8n/.n8n

15º Passo - Gere uma chave de criptografia nova com o comando abaixo, vamos usar em seguida.

openssl rand -base64 48

16º Passo - Crie um arquivo .env para o serviço (centraliza configs e fica fácil de manter):

sudo nano /home/n8n/.n8n/.env

17º Passo - Copie o conteúdo abaixo no arquivo .env que você acabou de criar.

# ===== Core =====
N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
N8N_USER_FOLDER=/home/n8n/.n8n
N8N_HOST=IP-DO-SEU-SERVIDOR
N8N_PORT=5678
# Se for expor publicamente, defina BASE_URL (https://seu-dominio):
# N8N_EDITOR_BASE_URL=https://seu-dominio
# WEBHOOK_URL=https://seu-dominio/
N8N_RUNNERS_ENABLED=true
N8N_SECURE_COOKIE=false
# ===== Banco (Postgres) =====
DB_TYPE=postgresdb
DB_POSTGRESDB_HOST=127.0.0.1
DB_POSTGRESDB_PORT=5432
DB_POSTGRESDB_DATABASE=n8n_db
DB_POSTGRESDB_USER=n8n_user
DB_POSTGRESDB_PASSWORD=coloque-sua-senha-super-forte-aqui
# Pool (opcional, melhora estabilidade)
DB_POSTGRESDB_POOL_SIZE=10

# ===== Segurança (ajuste conforme seu cenário) =====
# Basic Auth no editor
#N8N_BASIC_AUTH_ACTIVE=true
#N8N_BASIC_AUTH_USER=admin
#N8N_BASIC_AUTH_PASSWORD=outra-senha-super-forte

# Chave de criptografia para credenciais
N8N_ENCRYPTION_KEY=COLOQUE-AQUI-A-CHAVE-DE-CRIPTOGRAFIA-QUE-VOCE-GEROU

# ===== Filas (opcional) - se usar filas com Redis =====
# QUEUE_BULL_REDIS_HOST=127.0.0.1
# QUEUE_BULL_REDIS_PORT=6379

18º Passo - Aplique permissões restritivas:

sudo chmod 600 /home/n8n/.n8n/.env

19º Passo - Crie o arquivo de serviço para rodar o n8n com o systemd.
Isso garante que o n8n seja iniciado automaticamente junto com o servidor e seja monitorado.

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

20º Passo - Copie o conteúdo abaixo para o arquivo que você acabou de criar.

[Unit]
Description=n8n Automation (Workflow) Service
After=network-online.target postgresql.service
Wants=network-online.target

[Service]
# Usuário dedicado
User=n8n
Group=n8n
EnvironmentFile=/home/n8n/.n8n/.env
WorkingDirectory=/home/n8n

# Início do app
ExecStart=/usr/local/bin/n8n start
Restart=always
RestartSec=5

# Limites e robustez
LimitNOFILE=65535

# Logs no journal (journalctl)
StandardOutput=journal
StandardError=journal

# Hardening (ajuste se precisar de acesso fora do home)
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full
ProtectHome=read-only
ReadWritePaths=/home/n8n /tmp /var/tmp

# Se o n8n precisar bindar portas <1024, remova a linha abaixo
CapabilityBoundingSet=
AmbientCapabilities=

# Timeout maior para migrações iniciais
TimeoutStartSec=120

[Install]
WantedBy=multi-user.target

21º Passo - Recarregue o systemd, habilite o serviço do n8n na inicialização e inicie-o imediatamente.

sudo systemctl daemon-reload
sudo systemctl enable n8n
sudo systemctl start n8n

22º Passo - Verifique se o serviço está rodando corretamente.

systemctl status n8n
journalctl -u n8n -f

Solução de Problemas

Se aparecer erro de migração/permite no Postgres, rode um teste manual:

sudo -u n8n env $(cat /home/n8n/.n8n/.env | xargs) n8n start

Assim você vê erros com as mesmas variáveis do serviço.

Te ajudei?

Me paga uma cerveja! 🍺😁

PIX QrCode

Atualize os pacotes e instale o servidor PostgreSQL:

sudo apt update && sudo apt upgrade -y

Instale o servidor PostgreSQL

sudo apt install postgresql postgresql-contrib -y

Verifique se o serviço está ativo:

sudo systemctl status postgresql

📌 2. Criar um novo banco e alterar a senha do usuário

Entre no usuário administrativo postgres:

sudo -i -u postgres

Abra o prompt do PostgreSQL:

psql

Agora execute os comandos SQL:

-- Criar banco de dados
CREATE DATABASE n8n_db;

-- Alterar a senha do usuario postgres
ALTER USER postgres PASSWORD 'sua_nova_senha';


-- Dar permissões ao usuário no banco
GRANT ALL PRIVILEGES ON DATABASE n8n_db TO postgres;

🔹 Pré-requisitos

• Ubuntu Server 22.04
• Acesso root ou sudo
• Conexão com a internet

🛠️ Passos para Instalação

1️⃣ Atualize o sistema

sudo apt update && sudo apt upgrade -y

2️⃣ Baixe o pacote .deb do MinIO (Community Edition)

Substitua <versao> pelo número da versão (por exemplo, RELEASE.2025-05-25T10-00-00Z):

wget https://dl.min.io/server/minio/release/linux-amd64/archive/minio_<versao>_amd64.deb

3️⃣ Instale o pacote .deb

sudo dpkg -i minio_<versao>_amd64.deb

Se aparecer erro de dependências:

sudo apt --fix-broken install

4️⃣ Verifique a instalação

which minio
minio --version

⚙️ Configuração do MinIO

5️⃣ Crie o usuário e diretórios

sudo useradd -r minio-user -s /sbin/nologin
sudo mkdir -p /usr/local/share/minio
sudo mkdir -p /etc/minio
sudo chown minio-user:minio-user /usr/local/share/minio /etc/minio

6️⃣ Configure as variáveis de ambiente

sudo nano /etc/default/minio

Adicione o conteúdo:

MINIO_VOLUMES="/usr/local/share/minio"
MINIO_OPTS="--console-address :9001"
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=minioadmin123

7️⃣ Configure o systemd para iniciar o MinIO como serviço

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

Adicione:

[Unit]
Description=MinIO
Documentation=https://min.io/docs/
Wants=network-online.target
After=network-online.target

[Service]
User=minio-user
Group=minio-user
EnvironmentFile=/etc/default/minio
ExecStart=/usr/bin/minio server $MINIO_OPTS $MINIO_VOLUMES
Restart=always
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

8️⃣ Recarregue e inicie o serviço

sudo systemctl daemon-reload
sudo systemctl enable minio
sudo systemctl start minio
sudo systemctl status minio

🌐 Acessar o MinIO Console

Abra o navegador e acesse:

http://<seu-ip>:9001

Use as credenciais definidas em /etc/default/minio.

🔒 Abrir portas no firewall (se necessário)

sudo ufw allow 9000
sudo ufw allow 9001
sudo ufw reload

📝 Observações

• O pacote .deb não deve ser usado diretamente como binário, ele precisa ser instalado com dpkg -i.
• O MinIO Community Edition é licenciado sob AGPL v3, com recursos essenciais e sem suporte comercial.
• Configure /etc/default/minio e /etc/systemd/system/minio.service para ajustar diretórios e opções.

1 - Atualiza a Lista de Pacotes

Antes de começar, certifique-se de que sua lista de pacotes está atualizada:

sudo apt-get update

Instalação e Configuração do PostgreSQL

2 - Instalar PostgreSQL

2.1 - Execute o comando abaixo para instalar o PostgreSQL

sudo apt-get install postgresql postgresql-contrib

2.2 - Inicie o serviço com o comando abaixo

sudo service postgresql start

2.3 - Execute o comando para criar o banco de dados.

sudo -u postgres createdb evolution

2.4 - Conecte-se ao PostgreSQL

sudo -u postgres psql

2.5 - Alterar a senha do usuário do PostgreSQL.

Vamos alterar a senha do usuário postgres.

🚨**Anote essa senha, pois você vai usá-la posteriormente!**🚨

ALTER USER postgres WITH PASSWORD 'senha-do-banco';

Para sair do terminal do PostgreSQL, digite:

\q

3 - Instalação e Configuração do Redis

3.1. Instalar Redis

O Redis está disponível nos repositórios padrão do Ubuntu. Para instalá-lo, use o seguinte comando:

sudo apt-get install redis-server

3.2. Verificar o Funcionamento do Redis

Após a instalação, o serviço Redis deve iniciar automaticamente. Verifique se o Redis está em execução com:

redis-cli ping

Você deve receber um “PONG” como resposta do comando.

4. Melhorando a segurança

4.1. Permitir Conexões Locais

Primeiro, permita conexões de localhost (127.0.0.1) para as portas 6379(REDIS) e 5432(PostgreSQL):

sudo ufw allow from 127.0.0.1 to any port 6379
sudo ufw allow from 127.0.0.1 to any port 5432

4.2. Bloquear Acesso Externo

Bloqueie o acesso externo às portas do Redis e PostgreSQL para evitar conexões indesejadas:

sudo ufw deny 6379
sudo ufw deny 5432

4.3. Permitir Acesso à Porta 22 (SSH) e 8080

Certifique-se de permitir o tráfego na porta 22, usada para conexões SSH, e na porta 8080, onde a Evolution API será executada:

sudo ufw allow 22/tcp
sudo ufw allow 8080

4.4. Ativar o Firewall (UFW)

Ative o ufw para aplicar as regras de segurança configuradas:

sudo ufw enable

Responda y caso a pergunta abaixo apareça:

4.5. Verificar as Regras Atuais

Após configurar as regras, verifique se elas foram aplicadas corretamente:

sudo ufw status verbose

Você verá algo como mostrado abaixo:

5. Instalação do Node.js com NVM

5.1. Instalar o NVM

Instale o Node Version Manager (NVM) para gerenciar versões do Node.js:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash

5.2. Carregar o NVM no Ambiente

Carregue o NVM no ambiente com o comando abaixo:

source ~/.bashrc

5.3. Instalar e Usar o Node.js

Agora, instale e use a versão 20.10.0 do Node.js:

nvm install v22.14.0 && nvm use v22.14.0

5.4. Verificar Instalação do NVM

Confirme que o NVM foi instalado com sucesso:

command -v nvm

6. Instalação e Configuração da Evolution API

6.1. Clonar o Repositório da API

Clone o repositório oficial da Evolution API v2 a partir da branch correta:

git clone --branch 2.2.3 https://github.com/EvolutionAPI/evolution-api.git

6.2. Instalar Dependências

Acesse o diretório do projeto e instale as dependências necessárias:

cd evolution-api && npm install

7. Configuração das Variáveis de Ambiente

7.1. Copiar Arquivo de Exemplo .env

Copie o arquivo de exemplo .env.example para .env:

cp ./.env.example ./.env

7.2. Editar o Arquivo .env

Edite o arquivo .env e substitua os valores conforme necessário. As variáveis mais importantes são as de conexão com o banco de dados:

nano ./.env

Altere os seguintes valores:

• DB_USER: postgres

• DB_PASS: a senha do banco que você definiu anteriormente

Você também 🚨PRECISA MUDAR🚨 e anotar a API Key Global, pois você precisará dela para acessar a plataforma. A instalação padrão vem com essa chave, ou seja, é um risco a sua segurança.

(documentação do arquivo .env aqui)

8. Geração e Deploy do Banco de Dados

Após configurar o ambiente, você precisará realizar a geração dos arquivos do cliente Prisma e o deploy das migrations no banco de dados. Utilize os comandos abaixo.

8.1. Gerar Arquivos Prisma

Gerar os arquivos do cliente Prisma:

npm run db:generate

8.2. Deploy das Migrations

Realize o deploy das migrations para configurar o banco de dados:

npm run db:deploy

9. Inicializando a Evolution API

Após todas as configurações, inicie a Evolution API:

npm run build && npm run start:prod

10. Gerenciamento com PM2

10.1. Instalar PM2

Para gerenciar a API, instale o PM2:

npm install pm2 -g

10.2. Iniciar a Evolution API com PM2

Inicie a API com PM2 e configure o PM2 para inicializar automaticamente:

pm2 start 'npm run start:prod' --name ApiEvolution &&
pm2 startup &&
pm2 save --force

11. Verificar a API

Para verificar se a API está em execução, acesse o IP do servidor na porta 8080 (http://ip-do-servidor:8080). Você deve receber a seguinte resposta:

{
  "status": 200,
  "message": "Welcome to the Evolution API, it is working!",
  "version": "2.0.10",
  "clientName": "evolution01",
  "manager": "https://evo2.site.com/manager",
  "documentation": "https://doc.evolution-api.com"
}

Acesse a interface de gerenciamento em:

http://<IP-DO-SEU-SERVIDOR>:8080/manager/login

No campo API Key Global, informe a chave que você configurou no arquivo .env.

12. Finalizando

Tudo pronto! Agora você pode acessar a Evolution API e gerenciá-la diretamente pela interface. Não esqueça de salvar as configurações e realizar testes para garantir que tudo esteja funcionando corretamente.

Te ajudei?

Me paga uma cerveja! 🍺😁

PIX QrCode

Crie um arquivo com o nome de webpack.mix.js na raiz do seu projeto, edite e deixe como abaixo.

let mix = require('laravel-mix');

/*
 |--------------------------------------------------------------------------
 | Mix Asset Management
 |--------------------------------------------------------------------------
 |
 | Mix provides a clean, fluent API for defining some Webpack build steps
 | for your Laravel application. By default, we are compiling the Sass
 | file for the application as well as bundling up all the JS files.
 |
 */

mix.js('resources/js/app.js', 'public/js')
    .sass('resources/sass/app.scss', 'public/css')
    .sourceMaps();

Altere o arquivo package.json

Original

{
    "private": true,
    "type": "module",
    "scripts": {
        "dev": "vite",
        "build": "vite build"
    },
    "devDependencies": {
        "@popperjs/core": "^2.11.6",
        "axios": "^1.1.2",
        "bootstrap": "^5.2.3",
        "laravel-vite-plugin": "^0.8.0",
        "sass": "^1.56.1",
        "vite": "^4.0.0"
    }
}

Modificado

{
    "private": true,
    "scripts": {
        "dev": "npm run development",
        "development": "mix",
        "watch": "mix watch",
        "watch-poll": "mix watch -- --watch-options-poll=1000",
        "hot": "mix watch --hot",
        "prod": "npm run production",
        "production": "mix --production"
    },
    "devDependencies": {
        "@popperjs/core": "^2.11.6",
        "axios": "^1.1.2",
        "bootstrap": "^5.2.3",
        "laravel-mix": "^6.0.49",
        "lodash": "^4.17.19",
        "postcss": "^8.1.14",
        "resolve-url-loader": "^5.0.0",
        "sass": "^1.56.1",
        "sass-loader": "^12.6.0"
    }
}

Edite o arquivo .env, localize as variáveis abaixo e substitua

Original

VITE_APP_NAME="${APP_NAME}"
VITE_PUSHER_APP_KEY="${PUSHER_APP_KEY}"
VITE_PUSHER_HOST="${PUSHER_HOST}"
VITE_PUSHER_PORT="${PUSHER_PORT}"
VITE_PUSHER_SCHEME="${PUSHER_SCHEME}"
VITE_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"

Modificado

MIX_PUSHER_APP_KEY="${PUSHER_APP_KEY}"
MIX_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"

Nos arquivos blade, você deve trocar chamadas do vite pelas do mix.

A exemplo do arquivo app.blade.php

Original

    <!-- Scripts -->
    @vite(['resources/sass/app.scss', 'resources/js/app.js'])

Modificado

<!-- Scripts -->
<link rel="stylesheet" href="{{ mix('css/app.css') }}">

Remova o vite, execute os comandos abaixo na raiz do projeto.

npm remove vite laravel-vite-plugin

Remova o arquivo de configuração

rm vite.config.js

sudo apt update && sudo apt upgrade

No site oficial do node.js você pode baixar os binários mais recentes como mostra a figura abaixo. Na data que escrevo, a versão LTS(long time support) é a 22.19.0. Usaremos ela neste tutorial.

2º - Use o comando abaixo no seu terminal para baixar os binários.

curl -o node.tar.xz https://nodejs.org/dist/v22.19.0/node-v22.19.0-linux-x64.tar.xz

3º - Use o comando abaixo para descompatar o pacote e entrar na pasta.

tar -xf node.tar.xz && cd node-v22.19.0-linux-x64

4º - Com o comando abaixo, vamos copiar os arquivos para que fiquem disponíveis globalmente.

sudo cp -R * /usr/local/

Pronto! Feito isso o noje deve estar disponível para uso. Execute os comandos abaixo para verificar.

node -v && npm -v

Se tudo estiver correto, você deve ver algo como mostrado na figura.

Para uma introdução ao Git e como instalar, consulte o tutorial de introdução.

Este artigo ensinará como usar o Git quando quiser implantar seu aplicativo. Embora existam muitas maneiras de usar o Git para implantar nosso aplicativo, este tutorial se concentrará na mais direta. Presumo que você já saiba como criar e usar um repositório em sua máquina local. Caso contrário, consulte este tutorial.

Quando você usa o Git, o fluxo de trabalho geralmente é voltado apenas para o controle de versão. Você tem um repositório local onde trabalha e um repositório remoto onde mantém tudo sincronizado e pode trabalhar com uma equipe e máquinas diferentes. Mas você também pode usar o Git para mover seu aplicativo para produção.

Configuração do Servidor

Nosso espaço de trabalho fictício:

O diretório ao vivo do seu servidor: /var/www/domain.com

Seu repositório do servidor: /var/repo/site.git

O que devemos fazer se quisermos enviar para site.git e ao mesmo tempo disponibilizar todo o conteúdo em /var/www/domain.com?

Criando nosso repositório

Faça login no seu VPS a partir da linha de comando e digite o seguinte:

cd /var && mkdir repo && cd repo && mkdir site.git && cd site.git && git init --bare

--bare significa que nossa pasta não terá arquivos de origem, apenas o controle de versão.

Hooks

Os repositórios Git têm uma pasta chamada 'hooks'. Esta pasta contém alguns arquivos de amostra para possíveis ações que você pode conectar e executar ações personalizadas definidas por você.

A documentação do Git define três ganchos de servidor possíveis: 'pré-receber', 'pós-receber' e 'atualizar'. 'Pré-recebimento' é executado assim que o servidor recebe um 'push', 'atualização' é semelhante, mas é executado uma vez para cada ramificação, e 'pós-recebimento' é executado quando um 'push' é completamente finalizado e é o um em que estamos interessados.

Em nosso repositório, se você digitar:

ls

Você verá alguns arquivos e pastas, incluindo a pasta 'hooks'. Então vamos para a pasta 'hooks':

cd hooks

Agora, crie o arquivo 'post-receive' digitando:

cat > post-receive

Ao executar este comando, você terá uma linha em branco indicando que tudo o que você digitar será salvo neste arquivo. Então vamos digitar:

#!/bin/sh 
git --work-tree=/var/www/domain.com --git-dir=/var/repo/site.git checkout -f

Quando terminar de digitar, pressione 'control-d' para salvar. Para executar o arquivo, precisamos definir as permissões apropriadas usando:

chmod +x post-receive

Você pode ver na documentação que 'git-dir' é o caminho para o repositório. Com 'árvore de trabalho', você pode definir um caminho diferente para onde seus arquivos serão realmente transferidos.

O arquivo 'post-receive' será analisado toda vez que um push for concluído e está dizendo que seus arquivos precisam estar em /var/www/domain.com.

Local Machine

Vamos criar nosso repositório local. Você deve alterar o caminho e o nome para o que você escolher. Se você estiver em um VPS, basta digitar:

exit

E crie seu repo:

cd /my/workspace && mkdir project && cd project && git init

Então precisamos configurar o caminho remoto do nosso repositório. Diga ao Git para adicionar um controle remoto chamado 'live':

git remote add live ssh://user@mydomain.com/var/repo/site.git

Aqui devemos dar o link do repositório e não a pasta live.

Vamos supor que temos um ótimo trabalho pronto nesta pasta. Devemos seguir os passos usuais de adicionar os arquivos e confirmar com uma mensagem:

git add . && git commit -m "My project is ready"

Só para lembrar, o ponto após 'git add' significa que você está adicionando todos os arquivos ao stage. Depois de 'git commit', temos '-m', o que significa que digitaremos uma mensagem. Para completar, basta 'empurrar' tudo para o servidor. Usamos o alias 'ao vivo' que usamos ao configurar o controle remoto.

git push --set-upstream live master

Counting objects: 7, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (7/7), done.
Writing objects: 100% (7/7), 10.56 KiB, done.
Total 7 (delta 0), reused 0 (delta 0)To ssh://user@mydomain.com/var/repo/site.git* [new branch] master -> master

Aqui, dizemos ao Git para enviar para a branch remota 'live' na ramificação 'master'.

Primeiro, vamos atualizar os pacotes existentes em seu sistema operacional. Para fazer isso, abra um terminal e digite os seguintes comandos:

sudo apt update
sudo apt -y upgrade

MySQL

Agora você pode instalar o pacote do servidor MySQL executando o seguinte comando:

sudo apt install mysql-server

Durante a instalação, você será solicitado a definir uma senha para o usuário "root" do MySQL. Escolha uma senha segura e lembre-se dela, pois você precisará dela mais tarde.

Passo 3: Inicie o serviço do MySQL Após a conclusão da instalação, o serviço do MySQL deve ser iniciado automaticamente. No entanto, se o serviço não iniciar, você pode iniciar manualmente usando o seguinte comando:

sudo service mysql start

Passo 4: Verifique o status do serviço MySQL Você pode verificar se o serviço do MySQL está em execução executando o seguinte comando:

sudo service mysql status

Se estiver em execução, você deverá ver uma mensagem indicando que o serviço está ativo.

Passo 5: Acesse o servidor MySQL Por padrão, a instalação do MySQL no Ubuntu usa autenticação baseada em senha. Você pode acessar o servidor MySQL usando o seguinte comando:

sudo mysql -uroot

Vamos alterar a senha do usuário root.

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'SUA-SENHA-AQUI';
FLUSH PRIVILEGES;

Após executar essas etapas, você terá o MySQL instalado e pronto para uso no seu sistema Ubuntu. Agora você pode criar bancos de dados, tabelas e executar consultas SQL no MySQL.

NGINX

sudo apt install nginx

Durante o processo de instalação, você será solicitado a confirmar. Pressione "Y" e depois "Enter" para continuar. Aguarde até que o processo de instalação seja concluído.
Depois de concluir esses passos, o Nginx estará instalado em seu sistema Ubuntu. Você pode verificar se o serviço está em execução digitando o endereço IP do seu servidor em um navegador da web. Você deve ver a página de boas-vindas padrão do Nginx, indicando que a instalação foi bem-sucedida.

PHP 8.2

Adicione o repositório, Ondřej Surý é um desenvolvedor que mantém um repositório com as versões mais recentes do PHP para Ubuntu. Você pode adicionar o repositório dele ao seu sistema usando os seguintes comandos:

sudo apt install software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt update

Agora que você adicionou o repositório do Ondřej, você pode instalar o PHP 8.2. Use este comando para fazer isso:

sudo apt install php8.2

Depois de instalado, você pode verificar se o PHP 8.2 foi corretamente instalado com o seguinte comando:

php -v

Este comando deve exibir informações sobre a versão do PHP que está atualmente ativa no seu sistema. Se você fez tudo corretamente, deve ver que a versão 8.2 está instalada.

Vamos instalar os módulos para trabalhar com MySQL e com o FPM e alguns outros.

sudo apt install php8.2-cli php8.2-common php8.2-fpm php8.2-mysql php8.2-curl php8.2-memcached php8.2-dev php8.2-pgsql php8.2-sqlite3 php8.2-mbstring php8.2-gd php8.2-imagick php8.2-imap php8.2-opcache php8.2-xmlrpc php8.2-xml php8.2-zip php8.2-bcmath php8.2-soap php8.2-intl php8.2-readline unzip -y

Você pode instalar outros módulos PHP de acordo com suas necessidades, aqui tenho uma lista de alguns.

Vamos integrar o PHP e NGINX

Primeiro vamos fazer o backup do arquivo de configuração padrão do NGINX, execute o comando abaixo.

sudo mv /etc/nginx/sites-available/default /etc/nginx/sites-available/default_config

Feito o backup, vamos criar um novo arquivo de configuração.

sudo nano /etc/nginx/sites-available/default

Copia a configuração abaixo e cole no novo arquivo de configuração.

server {

  # Port that the web server will listen on.
  listen 80;

  # Host that will serve this project.
  server_name localhost;

  # Useful logs for debug.
  access_log /var/log/nginx/localhost_access.log;
  error_log /var/log/nginx/localhost_error.log;
  rewrite_log on;

  # The location of our projects public directory.
  root /var/www/;

  # Point index of your project.
  index index.php index.html;

  location / {
    # URLs to attempt, including pretty ones.
    try_files $uri $uri/ /index.php?$query_string;
  }

  # Remove trailing slash to please routing system.
  if (!-d $request_filename) {
    rewrite ^/(.+)/$ /$1 permanent;
  }

  # PHP FPM configuration.
  location ~* \.php$ {
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
    fastcgi_index index.php;
    fastcgi_split_path_info ^(.+\.php)(.*)$;
    include /etc/nginx/fastcgi_params;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
  }

  location ~ /\.ht {
    deny all;
  }

}

Salve o arquivo ctrl+o em seguida enter e saia ctrl+x.

Vamos testasr a configuração que acabamos de fazer, ver se ficou tudo ok.

sudo nginx -t

Se tiver tudo ok, você deve ver uma imagem como esta

Agora vamos criar um arquivo chamado info.php para ver se nossa configuração funcionou.

sudo nano /var/www/index.php

Copie e cole o código abaixo.

<?php
phpinfo();

Volte ao navegador e acesse http://localhost/, desta vez você deve ver uma página com todas as informações do PHP 8.2.

php8.2-cli: É o módulo de linha de comando (Command Line Interface) do PHP 8.2. Ele permite a execução de scripts PHP diretamente no terminal.

php8.2-common: Contém arquivos comuns do PHP, como bibliotecas e configurações básicas necessárias para a maioria das aplicações.

php8.2-fpm: É o módulo FastCGI Process Manager do PHP 8.2. Ele fornece uma interface entre um servidor web e o PHP, permitindo o processamento eficiente de solicitações da web.

php8.2-mysql: Fornece suporte para a conexão e manipulação de bancos de dados MySQL no PHP 8.2.

php8.2-curl: Habilita o suporte para a biblioteca cURL, que permite o envio de requisições HTTP e outras operações relacionadas com protocolos de rede.

php8.2-memcached: Oferece suporte à extensão Memcached, que permite a utilização do serviço de armazenamento em cache distribuído Memcached.

php8.2-dev: É o módulo de desenvolvimento do PHP 8.2. Ele fornece ferramentas e bibliotecas adicionais para desenvolvedores PHP.

php8.2-pgsql: Fornece suporte para a conexão e manipulação de bancos de dados PostgreSQL no PHP 8.2.

php8.2-sqlite3: Habilita o suporte para o banco de dados SQLite 3 no PHP 8.2.

php8.2-mbstring: Fornece funções para manipulação de strings multibyte, como codificação, detecção de caracteres e conversão de caracteres.

php8.2-gd: Oferece suporte à biblioteca GD, permitindo a manipulação de imagens no PHP, como criação de miniaturas, redimensionamento e aplicação de efeitos.

php8.2-imagick: Habilita a extensão Imagick, que oferece recursos avançados de manipulação de imagens por meio da biblioteca ImageMagick.

php8.2-imap: Fornece suporte para a comunicação com servidores de email usando o protocolo IMAP, permitindo a leitura e manipulação de emails no PHP 8.2.

php8.2-opcache: É um mecanismo de armazenamento em cache interno do PHP 8.2 que melhora o desempenho ao pré-compilar e armazenar em cache o código PHP.

php8.2-xmlrpc: Habilita suporte ao protocolo XML-RPC, permitindo a criação de serviços web que podem ser acessados via XML-RPC.

php8.2-xml: Fornece funcionalidades para a manipulação e processamento de XML no PHP 8.2, como análise, validação e geração de documentos XML.

php8.2-zip: Habilita o suporte para a manipulação de arquivos ZIP no PHP 8.2, permitindo a criação, extração e manipulação de arquivos compactados ZIP.

php8.2-bcmath: Oferece funções matemáticas de precisão arbitrária (big number) no PHP 8.2, permitindo cálculos com números muito grandes ou com alta precisão.

php8.2-soap: Habilita o suporte ao protocolo SOAP (Simple Object Access Protocol), permitindo a criação e consumo de serviços web baseados em SOAP no PHP 8.2.

php8.2-intl: Fornece suporte para recursos internacionais, como formatação de datas, números e strings de acordo com diferentes localidades e culturas.

php8.2-readline: Habilita recursos de leitura interativa no PHP 8.2, permitindo a interação com o usuário através do terminal, incluindo recursos como histórico de comandos e autocompletar.

php8.2-json: Fornece suporte para codificação e decodificação de dados no formato JSON.

php8.2-ldap: Habilita o suporte para interação com servidores LDAP (Lightweight Directory Access Protocol) no PHP.

php8.2-redis: Oferece suporte à extensão Redis, permitindo a utilização do banco de dados em memória Redis.

php8.2-xdebug: Fornece recursos avançados de depuração para desenvolvedores, como rastreamento de código, perfil de execução e análise de pilha.

php8.2-ssh2: Habilita a comunicação segura por meio do protocolo SSH (Secure Shell) no PHP.

php8.2-imagick: Oferece recursos avançados de manipulação de imagens por meio da biblioteca ImageMagick.

php8.2-mongodb: Habilita a extensão MongoDB, permitindo a comunicação com bancos de dados MongoDB no PHP.

php8.2-odbc: Fornece suporte para conexão e manipulação de bancos de dados por meio do ODBC (Open Database Connectivity) no PHP.

php8.2-xmlrpc: Habilita suporte ao protocolo XML-RPC, permitindo a criação de serviços web que podem ser acessados via XML-RPC.

php8.2-xml: Fornece funcionalidades para a manipulação e processamento de XML no PHP, como análise, validação e geração de documentos XML.

The issue with Ubuntu 22.04 is using a display feature called wayland. Wayland is not supporting to screen share by default. In previous ubuntu version we had xorg for display feature.

To solve this what we have to do is

1. To check which display feature your ubuntu is using, enter the command below in terminal

echo $XDG_SESSION_TYPE

If the above command outputs, wayland, then your system is using wayland. Which is causing the problem. So we have to disable wayland and enable xorg(x11).

2. To change display settings from wayland to xorg(x11).

Go to file by entering the command below on terminal

sudo nano /etc/gdm3/custom.conf

You can use any of the editors like vim, nano etc…

3. Then, uncomment the line.

WaylandEnable=false

4. Save and then restart/reboot your system.

5. After restart, if we open up the terminal and type the command.

echo $XDG_SESSION_TYPE

We can see the output has changed from wayland to x11.

Now you can share your screen.

Reposted from lizenshakya

Se você está procurando uma maneira fácil de habilitar a comunicação bidirecional entre um servidor e um cliente em tempo real, o Soketi é a escolha ideal. Ele permite que você transmita informações instantaneamente e de forma assíncrona, sem a necessidade de atualizações constantes da página ou consultas repetitivas ao servidor.

Neste tutorial, você aprenderá como instalar e configurar o Soketi em uma máquina virtual hospedada na DigitalOcean, uma plataforma de computação em nuvem confiável e escalável.

Não é meu objetivo mostrar como configurar uma máquina na DO. Vou assumir que você já possui esse conhecimento.

Vamos lá.

Instalação

É necessário ter o Node.js LTS (14.x, 16.x, etc.) devido às limitações de compilação do uWebSockets.js.

O Soketi pode ser facilmente instalado através do NPM

npm install -g @soketi/soketi

Após a instalação, um servidor Soketi com a configuração padrão pode ser iniciado usando o comando

soketi start

Por padrão, o comando irá iniciar um servidor em 127.0.0.1:6001 com as seguintes credenciais de aplicativo:

• App ID: app-id

• App Key: app-key

• Secret: app-secret

Essas credenciais são usadas pra autenticar seus aplicativos no frontend e backend, permitindo que você mande e receba mensagens em tempo real.

Logo mais abaixo, te explico como você pode alterar.

Configuração do Servidor

Você pode declarar as configuração do servidor soketi usando variáveis de ambiente ao invocar diretamente o servidor soketi no console, ou como atributos chave-valor em um arquivo .env que é colocado no mesmo diretório onde o comando do servidor soketi é executado.

Exemplo de um arquivo .env

SOKETI_DEBUG=1
SOKETI_DEFAULT_APP_ID=1111
SOKETI_DEFAULT_APP_KEY=2222
SOKETI_DEFAULT_APP_SECRET=3333

Uma lista completa de variaveis de ambiente pode ser encontrada clicando aqui.

Exemplo de um arquivo de configuração config.json

{
    "debug":true,
    "appManager.array.apps":[
        {
            "id":"1111",
            "key":"2222",
            "secret":"3333"
        }
    ]
}

Uma lista completa de opções a serem configuradas pode ser encontrada clicando aqui.

Note que em ambos os arquivos de configuração, temos as informações de APP-ID, APP-KEY e APP-SECRET, você pode modificar esses valores livremente. O importante é que uma vez definidos, você use-os no momento de se conectar ao servidor soketi, seja no frontend ou no backend.

Iniciando o serviço

Lembre-se, se você optou por usar um arquivo de configuração json, deve iniciar o serviço como mostrado abaixo

soketi start --config=/path/to/config.json

Já se tiver optado por usar um arquivo .env, você deve iniciar o serviço no mesmo diretório onde o arquivo .env foi criado. Então a inicialização ficaria:

soketi start

Após iniciar o serviço, você deve ver algo como a figura abaixo:

Instalando o Supervisor

Para manter o servidor soketi permanentemente ativo, você deve instalar um gerenciador de processos, no nosso exemplo, iremos utilizar o supervisor, um daemon que pode executar e reiniciar processos em segundo plano.

Passo 1

Comece atualizando suas fontes de pacotes e instalando o Supervisor:

sudo apt update && sudo apt install supervisor

O serviço do Supervisor é executado automaticamente após a instalação. Você pode verificar o seu status utilizando o comando:

sudo systemctl status supervisor

Você deve ver algo no seu console parecido com:

Passo 2

Uma prática recomendada ao trabalhar com o Supervisor é escrever um arquivo de configuração para cada programa que ele irá gerenciar.

Crie o arquivo de configuração executando o comando abaixo:

sudo nano /etc/supervisor/conf.d/soketi.conf

Em seguida, cole o conteudo abaixo:

[program:soketi] 
process_name=%(program_name)s_%(process_num)02d 
command=soketi start --config=/PATH/TO/CONFIG-FILE
autostart=true 
autorestart=true 
stopasgroup=true 
killasgroup=true 
user=ubuntu 
numprocs=1 
redirect_stderr=true 
stdout_logfile=/var/log/soketi-supervisor.log 
stopwaitsecs=60 
stopsignal=sigint 
minfds=10240

Como você pode ver na configuração acima, um único servidor soketi será iniciado e este servidor reiniciará automaticamente em caso de falha. Os registros de log serão gravados em /var/log/soketi-supervisor.log.

É importante observar que as opções de configuração stopwaitsecs e stopsignal devem ser definidas como no exemplo acima. Se necessário, você pode aumentar o valor de stopwaitsecs para um valor maior. Esse é o número de segundos que o Supervisor permitirá que o soketi encerre todas as conexões de forma adequada quando o servidor estiver parando ou reiniciando.

Em ambientes Linux, tudo é um arquivo, incluindo os sockets ativos. Para rastrear as conexões de socket, o soketi cria um descritor de arquivo para cada conexão. Em alguns casos, você pode encontrar um limite suave de descritores de arquivo definido pelo seu sistema operacional. Nessa situação, você pode definir a opção de configuração minfds do Supervisor para um valor mais alto, permitindo que o sistema operacional gerencie mais conexões.

Um ponto importante a destacar é de que se você tiver optado por configurar o soketi com arquivo .env você precisa configurar o Supervisor para que o serviço seja executado em um diretório especifico, aquele onde você colocou o arquivo .env a configuração ficaria levemente diferente.

[program:soketi] 
process_name=%(program_name)s_%(process_num)02d 
directory=/PATH/WHERE/ENV-FILE/IS
command=soketi start 
...

É isso, se te ajudei, comente! Obrigado.