O LEMP é uma das stacks mais utilizadas para aplicações web em Linux. O nome representa:

• Linux
• Engine X — Nginx
• MySQL
• PHP

Neste artigo vamos configurar um ambiente LEMP moderno no Deepin 25, incluindo PHP-FPM, extensões normalmente utilizadas por frameworks como Laravel e Symfony, Composer e uma configuração básica do Nginx.

Stack utilizada

A configuração recomendada neste guia é:

Deepin: 25.x Nginx: 1.30.x Stable PHP: 8.5 PHP-FPM: 8.5 MySQL: 8.4 LTS Composer: 2.x 

Em outubro de 2026, o PHP 8.5 continua sob suporte ativo e recebe correções regulares. O PHP 8.6 ainda não é uma versão estável para produção.

O Nginx possui duas linhas principais de distribuição: stable e mainline. Para servidores convencionais, utilizaremos a linha stable. A versão estável atual é da série 1.30.x.

Para banco de dados, utilizaremos o MySQL 8.4 LTS, uma escolha conservadora e adequada para aplicações PHP que precisam de estabilidade e ampla compatibilidade. O repositório oficial do MySQL continua disponibilizando a série 8.4 LTS.

1. Atualizar o Deepin

Antes de instalar os serviços, atualize a lista de pacotes e os pacotes já instalados:

sudo apt update sudo apt upgrade -y 

Também podemos instalar algumas ferramentas que serão utilizadas durante a configuração:

sudo apt install -y \ curl \ wget \ ca-certificates \ gnupg \ lsb-release \ unzip 

Verifique a versão do sistema:

cat /etc/os-release 

No Deepin 25 você encontrará o repositório da série crimson.

O Deepin 25 utiliza oficialmente seu próprio repositório:

deb https://community-packages.deepin.com/deepin/beige/ crimson main commercial community 

Não substitua os repositórios do Deepin por repositórios Debian ou Ubuntu indiscriminadamente. Isso pode causar conflitos de dependências.

2. Instalar o Nginx

Começaremos instalando o servidor web:

sudo apt install -y nginx 

Inicie o serviço:

sudo systemctl start nginx 

Configure para iniciar automaticamente junto com o sistema:

sudo systemctl enable nginx 

Confira o status:

sudo systemctl status nginx 

A saída deve indicar:

Active: active (running) 

Verifique também a versão instalada:

nginx -v 

Você pode testar diretamente no navegador:

http://localhost 

Ou através do endereço IP da máquina.

Para descobrir o IP:

hostname -I 

3. Testar a configuração do Nginx

Uma regra importante ao administrar o Nginx é testar a configuração antes de reiniciar ou recarregar o serviço:

sudo nginx -t 

O resultado esperado é semelhante a:

syntax is ok test is successful 

Depois disso podemos recarregar:

sudo systemctl reload nginx 

Isso é preferível a reiniciar o serviço sempre que modificarmos somente arquivos de configuração.

4. Instalar o PHP

O PHP 8.5 foi lançado em novembro de 2025 e possui suporte ativo até 31 de dezembro de 2027 e atualizações de segurança até 31 de dezembro de 2029.

Antes de prosseguir, verifique quais versões estão disponíveis no Deepin:

apt-cache policy php apt-cache search php8 | grep fpm 

Se o repositório do sistema disponibilizar PHP 8.5, instale:

sudo apt install -y \ php8.5 \ php8.5-cli \ php8.5-fpm \ php8.5-common \ php8.5-mysql \ php8.5-curl \ php8.5-mbstring \ php8.5-xml \ php8.5-zip \ php8.5-gd \ php8.5-bcmath \ php8.5-intl \ php8.5-opcache 

Essas extensões cobrem grande parte das necessidades de aplicações PHP modernas, incluindo Laravel e Symfony.

Importante: não recomendo adicionar automaticamente o repositório packages.sury.org apontando para bookworm, trixie ou outro codename Debian apenas para obter uma versão mais nova do PHP. O Deepin 25 utiliza crimson e misturar repositórios de distribuições diferentes pode causar conflitos de bibliotecas.

5. Verificar o PHP

Confira a versão:

php -v 

A saída deve ser semelhante a:

PHP 8.5.x (cli) 

Veja os módulos carregados:

php -m 

Também podemos verificar especificamente algumas extensões:

php -m | grep -E 'curl|mbstring|mysqli|pdo_mysql|xml|zip|gd|intl' 

6. Configurar o PHP-FPM

Verifique o serviço:

sudo systemctl status php8.5-fpm 

Caso ainda não esteja iniciado:

sudo systemctl enable --now php8.5-fpm 

O PHP-FPM normalmente cria um socket semelhante a:

/run/php/php8.5-fpm.sock 

Podemos confirmar:

ls -la /run/php/ 

O socket será utilizado posteriormente pelo Nginx.

7. Configurar o PHP para desenvolvimento

O arquivo principal do PHP utilizado pelo FPM normalmente fica em:

/etc/php/8.5/fpm/php.ini 

Faça um backup antes de modificá-lo:

sudo cp \ /etc/php/8.5/fpm/php.ini \ /etc/php/8.5/fpm/php.ini.backup 

Edite:

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

Para uma máquina de desenvolvimento, algumas configurações úteis são:

memory_limit = 512M upload_max_filesize = 64M post_max_size = 64M max_execution_time = 120 date.timezone = America/Sao_Paulo 

Em desenvolvimento:

display_errors = On display_startup_errors = On error_reporting = E_ALL 

Em produção, prefira:

display_errors = Off display_startup_errors = Off log_errors = On 

Depois de alterar:

sudo systemctl restart php8.5-fpm 

8. Instalar o Composer

Atualmente o Composer está na série 2.x; em outubro de 2026, a versão estável publicada é da série 2.10.

Baixe o instalador:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');" 

Baixe dinamicamente a assinatura oficial:

EXPECTED_CHECKSUM="$(php -r 'copy("https://composer.github.io/installer.sig", "php://stdout");')" 

Calcule o hash do arquivo:

ACTUAL_CHECKSUM="$(php -r 'echo hash_file("sha384", "composer-setup.php");')" 

Valide:

if [ "$EXPECTED_CHECKSUM" != "$ACTUAL_CHECKSUM" ]; then >&2 echo 'ERROR: Invalid Composer installer checksum' rm composer-setup.php exit 1 fi 

Instale globalmente:

sudo php composer-setup.php \ --install-dir=/usr/local/bin \ --filename=composer 

Remova o instalador:

rm composer-setup.php 

Confira:

composer --version 

9. Instalar o MySQL

Para novos servidores, uma escolha bastante segura é o MySQL 8.4 LTS.

Antes de instalar, verifique o pacote disponível:

apt-cache policy mysql-server 

Se o Deepin disponibilizar diretamente o MySQL:

sudo apt install -y mysql-server mysql-client 

Depois da instalação:

sudo systemctl enable --now mysql 

Verifique:

sudo systemctl status mysql 

E consulte a versão:

mysql --version 

10. MySQL 8.4 LTS através do repositório oficial

Se você precisa especificamente do MySQL 8.4 LTS e a versão não estiver disponível no repositório do Deepin, o MySQL disponibiliza seu próprio repositório APT.

A Oracle disponibiliza atualmente um pacote mysql-apt-config responsável por configurar as versões oferecidas pelo repositório.

Contudo, existe uma consideração importante:

O MySQL declara suporte oficial para Debian e Ubuntu. O Deepin é uma distribuição Debian-like, mas não aparece explicitamente entre as plataformas suportadas pelo repositório APT do MySQL.

Por isso, em uma máquina de produção, prefira o pacote validado pelo Deepin ou teste cuidadosamente a compatibilidade antes de adicionar o repositório da Oracle.

11. Executar o mysql_secure_installation

Após instalar o MySQL, execute:

sudo mysql_secure_installation 

A ferramenta permite configurar itens como:

• política de senha;
• usuários anônimos;
• acesso remoto ao usuário root;
• banco de dados test;
• privilégios.

As perguntas apresentadas podem variar dependendo da versão instalada.

12. Acessar o MySQL

Em sistemas Debian-like, o usuário root do MySQL pode utilizar autenticação através do próprio sistema operacional.

Nesse caso:

sudo mysql 

13. Criar um usuário MySQL para desenvolvimento

Em vez de utilizar root nas aplicações, crie um usuário específico.

Entre no MySQL:

sudo mysql 

Crie o banco:

CREATE DATABASE app CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci; 

Crie o usuário:

CREATE USER 'app'@'localhost' IDENTIFIED BY 'uma-senha-forte'; 

Dê acesso somente ao banco necessário:

GRANT ALL PRIVILEGES ON app.* TO 'app'@'localhost'; 

Finalize:

FLUSH PRIVILEGES; 

Saia:

EXIT; 

Teste:

mysql -u app -p 

14. Criar o primeiro Virtual Host

Vamos criar um projeto em:

/var/www/app 

Crie o diretório:

sudo mkdir -p /var/www/app/public 

Altere o proprietário:

sudo chown -R $USER:$USER /var/www/app 

Crie um arquivo PHP de teste:

nano /var/www/app/public/index.php 

Adicione:

<?php phpinfo(); 

15. Configurar Nginx + PHP-FPM

Dependendo do pacote do Nginx presente no Deepin, você poderá ter uma estrutura semelhante a:

/etc/nginx/sites-available /etc/nginx/sites-enabled 

Crie:

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

Adicione:

server { listen 80; listen [::]:80; server_name app.test; root /var/www/app/public; index index.php index.html; charset utf-8; location / { try_files $uri $uri/ /index.php?$query_string; } location ~ \.php$ { include fastcgi_params; fastcgi_pass unix:/run/php/php8.5-fpm.sock; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param DOCUMENT_ROOT $document_root; } location ~ /\.ht { deny all; } } 

Ative:

sudo ln -s \ /etc/nginx/sites-available/app \ /etc/nginx/sites-enabled/app 

Teste:

sudo nginx -t 

Se estiver correto:

sudo systemctl reload nginx 

16. Configurar domínio local

Edite:

sudo nano /etc/hosts 

Adicione:

127.0.0.1 app.test 

Agora abra:

http://app.test 

A página do phpinfo() deverá aparecer.

17. Remover o phpinfo()

Não mantenha phpinfo() disponível em um servidor real.

Ele revela diversas informações do ambiente, como:

• versão do PHP;
• módulos instalados;
• caminhos internos;
• configurações do servidor;
• variáveis de ambiente.

Depois do teste:

rm /var/www/app/public/index.php 

18. Testar MySQL através do PHP

Crie novamente:

nano /var/www/app/public/index.php 

Use:

<?php $pdo = new PDO( 'mysql:host=localhost;dbname=app;charset=utf8mb4', 'app', 'uma-senha-forte', ); echo 'LEMP funcionando corretamente.'; 

Abra:

http://app.test 

Se tudo estiver configurado corretamente:

LEMP funcionando corretamente. 

Isso confirma o funcionamento de:

Nginx ↓ PHP-FPM ↓ PHP ↓ PDO ↓ MySQL 

19. Verificar todos os serviços

Nginx:

systemctl status nginx 

PHP-FPM:

systemctl status php8.5-fpm 

MySQL:

systemctl status mysql 

Também podemos verificar de uma vez:

systemctl is-active nginx php8.5-fpm mysql 

O esperado é:

active active active 

20. Conferir as versões instaladas

Execute:

nginx -v 

php -v 

mysql --version 

composer --version 

Também podemos executar:

printf "\nNginx:\n" nginx -v printf "\nPHP:\n" php -v printf "\nMySQL:\n" mysql --version printf "\nComposer:\n" composer --version 

21. Estrutura final

Depois de concluir a instalação teremos aproximadamente:

Deepin Linux │ ├── Nginx │ └── :80 / :443 │ ├── PHP 8.5 │ └── PHP-FPM │ └── /run/php/php8.5-fpm.sock │ ├── MySQL │ └── :3306 │ └── Composer └── /usr/local/bin/composer 

Para uma requisição PHP:

Browser │ ▼ Nginx │ ▼ PHP-FPM │ ▼ PHP 8.5 │ ▼ MySQL 

22. Comandos resumidos

Para referência, os principais comandos da configuração são:

sudo apt update sudo apt upgrade -y sudo apt install -y \ curl \ wget \ ca-certificates \ gnupg \ lsb-release \ unzip sudo apt install -y nginx sudo systemctl enable --now nginx 

PHP, caso PHP 8.5 esteja disponível nos repositórios configurados:

sudo apt install -y \ php8.5 \ php8.5-cli \ php8.5-fpm \ php8.5-common \ php8.5-mysql \ php8.5-curl \ php8.5-mbstring \ php8.5-xml \ php8.5-zip \ php8.5-gd \ php8.5-bcmath \ php8.5-intl \ php8.5-opcache sudo systemctl enable --now php8.5-fpm 

MySQL:

sudo apt install -y mysql-server mysql-client sudo systemctl enable --now mysql sudo mysql_secure_installation 

Composer:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');" EXPECTED_CHECKSUM="$(php -r 'copy("https://composer.github.io/installer.sig", "php://stdout");')" ACTUAL_CHECKSUM="$(php -r 'echo hash_file("sha384", "composer-setup.php");')" if [ "$EXPECTED_CHECKSUM" != "$ACTUAL_CHECKSUM" ]; then >&2 echo 'ERROR: Invalid Composer installer checksum' rm composer-setup.php exit 1 fi sudo php composer-setup.php \ --install-dir=/usr/local/bin \ --filename=composer rm composer-setup.php 

Finalmente:

nginx -v php -v mysql --version composer --version 

Com isso temos um ambiente LEMP moderno no Deepin pronto para receber aplicações PHP.