WordPress na pilha LEMP (Linux, Nginx, MariaDB e PHP)

O WordPress é um sistema de código aberto para gestão de conteúdo para internet, baseado em PHP com banco de dados MariaDB/MySQL, executado em um servidor interpretador, voltado principalmente para a criação de portais de internet, e blogs online.

Este artigo irá guiá-lo como instalar o WordPress no Ubuntu 22.04 com o servidor web Nginx, MariaDB, PHP 8.1 e certificado SSL da Let’s encrypt.

PRÉ-REQUISITOS

– Um servidor Ubuntu 22.04 instalado com IP estático (ex: 172.16.15.3) e devidamente atualizado.

– Acesso SSH e logado como usuário root.

– Um nome de domínio apontado para seu servidor: Para garantir conexões do WordPress com protocolos TLS/SSL. O WordPress pode configurar e gerenciar um certificado SSL gratuito e confiável da Let’s Encrypt se seu servidor tiver um nome de domínio (ex: ENGESIS.com.br). Se não tiver um nome de domínio, é possível definir um certificado SSL autoassinado que possa criptografar conexões, porém, ele não será confiável por padrão em navegadores Web.

 

CONFIGURAÇÕES IMPORTANTES

A fim de melhorar a segurança de seu servidor, vamos fazer alguns ajustes no arquivo de configuração do SSH:

Edite o arquivo de configuração:

vim /etc/ssh/sshd_config

Altere a porta padrão de acesso SSH (ex: 4822 ou outra disponível). Procure pela diretiva “#Port 22”, retire o símbolo de comentário (#) e coloque o número da porta desejada.

Port 4822

Vamos impedir logins com senhas vazias. Procure pela diretiva “#PermitEmptyPassword no” e retire o símbolo de comentário (#) para ativar essa função.

PermitEmptyPassword no

Para concluir, reinicie o serviço SSH:

systemctl restart sshd

Definir a região de fuso horário:

dpkg-reconfigure tzdata

Atualize o servidor e limpe itens não mais necessários:

apt update && apt upgrade
apt autoremove
apt autoclean
apt clean

CONFIGURAÇÕES DE FIREWALL

Supondo que você esteja usando o UFW para gerenciar seu firewall, será necessário abrir as portas HTTP ( 80 ) e HTTPS ( 443 ) e SSH (4822).

ufw allow 80
ufw allow 443
ufw allow 4822
enable

Instalação do NGINX

No momento em que este tutorial está sendo escrito, a versão padrão do NGINX no Ubuntu 22.04 é a 1.18.0 e é totalmente suportado e recomendado para o WordPress. por ser padrão, não é necessário indicar a versão na instalação:

apt install nginx

Habilite o NGINX para iniciar no boot:

systemctl enable nginx

Confira se o serviço NGINX está em execução:

systemctl status nginx

A saída deve ser semelhante com a mensagem a seguir:

● nginx.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
     Active: active (running) since Tue 2023-03-21 18:46:48 -03; 1min 48s ago
       Docs: man:nginx(8)
   Main PID: 181036 (nginx)
      Tasks: 5 (limit: 9491)
     Memory: 6.9M
        CPU: 60ms
     CGroup: /system.slice/nginx.service
             ├─181036 "nginx: master process /usr/sbin/nginx -g daemon on; master_process on;"
             ├─181038 "nginx: worker process" "" "" "" "" "" "" "" "" ""
             ├─181039 "nginx: worker process" "" "" "" "" "" "" "" "" ""
             ├─181040 "nginx: worker process" "" "" "" "" "" "" "" "" ""
             └─181041 "nginx: worker process" "" "" "" "" "" "" "" "" ""

Instalação do PHP 8.1

No momento em que este tutorial está sendo escrito, a versão padrão do PHP no Ubuntu 22.04 é a 8.1 e é totalmente suportado e recomendado para o WordPress e diversas outras aplicações web.

O NGINX não contém processamento PHP nativo como alguns outros servidores web como o Apache. É necessário então a instalação do PHP-FPM “Gerenciador de processo fastCGI” para poder interpretar a linguagem PHP. 

No terminal, use o seguinte comando para instalar o PHP, PHP-CLI e PHP-FPM:

apt install php php-fpm php-cli

Depois de instalado, o serviço PHP-FPM é iniciado automaticamente e é possível verificar o status o serviço:

systemctl status php8.1-fpm

A saída deve ser semelhante ao conteúdo a seguir:

php8.1-fpm.service - The PHP 8.1 FastCGI Process Manager
     Loaded: loaded (/lib/systemd/system/php8.1-fpm.service; enabled; vendor preset: enabled)
     Active: active (running) since Tue 2023-03-21 18:57:49 -03; 1min 46s ago
       Docs: man:php-fpm8.1(8)
    Process: 190210 ExecStartPost=/usr/lib/php/php-fpm-socket-helper install /run/php/php-fpm.sock /etc/php/8.1/fpm/pool.d/www.conf 81 (code=exited, status=0/SUCCESS)
   Main PID: 190207 (php-fpm8.1)
     Status: "Processes active: 0, idle: 2, Requests: 0, slow: 0, Traffic: 0req/sec"
      Tasks: 3 (limit: 9491)
     Memory: 7.1M
        CPU: 84ms
     CGroup: /system.slice/php8.1-fpm.service
             ├─190207 "php-fpm: master process (/etc/php/8.1/fpm/php-fpm.conf)" "" "" 
             ├─190208 "php-fpm: pool www" "" "" "" "" "" "" "" "" "" "" ""
             └─190209 "php-fpm: pool www" "" "" "" "" "" "" "" "" "" "" ""

Mar 21 18:57:49 vmi1103709 systemd[1]: Starting The PHP 8.1 FastCGI Process Manager...
Mar 21 18:57:49 vmi1103709 systemd[1]: Started The PHP 8.1 FastCGI Process Manager.

Instale as extensões php mais comuns necessárias para o WordPress com o seguinte comando:

apt install php-common php-mysql php-xml php-xmlrpc php-curl php-gd php-imagick php-cli php-dev php-imap php-mbstring php-opcache php-soap php-zip php-redis php-intl php-ldap -y

Confira a versão do PHP:

php --version

 A saída do comando deve ser semelhante ao conteúdo a seguir:

PHP 8.1.2-1ubuntu2.11 (cli) (built: Feb 22 2023 22:56:18) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
    with Zend OPcache v8.1.2-1ubuntu2.11, Copyright (c), by Zend Technologies

Configurar O NGInx para interpretar PHP

Por padrão, o servidor NGINX não é capaz de interpretar código PHP, por isso, vamos fazer alguns ajustes em seu arquivo padrão de configuração:

nano /etc/nginx/sites-available/default

Neste arquivo, procure a linha que contém todos os tipos de arquivos que são executados por padrão. Essa linha deve estar abaixo da linha de configuração de root (root /var/www/html;).

Adicione “index.php” nessa linha, como mostrado a seguir:

root /var/www/html;

# Add index.php to the list if you are using PHP
index index.php index.html index.htm index.nginx-debian.html;

Precisamos também definir que o NGINX irá utilizar a versão correta do PHP e ativar a diretiva location ~ \.php$.

Desça um pouco mais, até próximo da linha 56 e retire o # para descomentar a linha location ~ \.php$ {
Descomente também a linha include snippets/fastcgi-php.conf;
Descomente a linha fastcgi_pass unix:/var/run/php/php8.1-fpm.sock; Caso esta linha esteja diferente de “php8.1-fpm.sock”, altere, pois é a versão do PHP que estamos utilizando.
Descomente a chave } de fechamento do bloco”.

A diretiva deve ficar como o mostrado a seguir:

location ~ \.php$ {
include snippets/fastcgi-php.conf;
# With php-fpm (or other unix sockets):
fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
# With php-cgi (or other tcp sockets):
# fastcgi_pass 127.0.0.1:9000;
}

Teste o NGINX para conferir se não houve algum erro na edição desse arquivo:

nginx -t

A saída deve ser:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Reinicie os serviços NGINX e o PHP:

systemctl restart nginx && systemctl restart php-fpm

Habilitar o Gzip no NGInx

O gzip é usado para compactar os arquivos que o seu website manda para o navegador e assim ganhar velocidade na transmissão desses dados. Vamos então adicionar algumas linhas no arquivo padrão de configuração:

nano /etc/nginx/sites-available/default

Adicione as seguintes linhas ao final do arquivo:

[gzip]
gzip on;
gzip_vary on;
gzip_proxied any;
gzip_comp_level 6;
gzip_buffers 16 8k;
gzip_http_version 1.1;
gzip_types image/svg+xml text/plain text/html text/xml text/css text/javascript application/xml application/xhtml+xml application/rss+xml application/javascript application/x-javascript application/x-font-ttf application/vnd.ms-fontobject font/opentype font/ttf font/eot font/otf;

Teste o NGINX para conferir se não houve algum erro na edição desse arquivo:

nginx -t

A saída deve ser:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Configurar o tamanho de arquivos para upload no NGINX e PHP

Quando se deseja fazer upload de arquivos (plugins, temas, etc.) via interface do WordPress, é necessário definir o limite máximo permitido pelas diretivas padrões do NGINX e do PHP. No caso, as diretivas são “client_max_body_size” e “upload_max_filesize”, respectivamente. Edite o arquivo de configuração do servidor web (nginx.conf)

nano /etc/nginx/nginx.conf

Neste arquivo, adicione a diretiva abaixo dentro de http:

#Aumentar o limite de upload do usuário para 256 MB ou o tamanho que desejar.
#Deve ser o mesmo valor da diretiva "upload_max_filesize", do arquivo "/etc/php/8.1/fpm/php.ini"

client_max_body_size 256M;

Ajustar configurações do PHP para permitir upload de arquivos maiores e maior tempo de processamento

Antes da criação do banco de dados, pode-se definir os parâmetros recomendados no arquivo php.ini:

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

Ajuste os seguintes campos para os valores abaixo ou de acordo com suas necessidades:

max_execution_time = 600
max_input_time = 1000
memory_limit = 2048M
post_max_size = 128M

#Coloque o mesmo valor colocado na diretiva "client_max_body_size", do arquivo /etc/nginx/nginx.conf
upload_max_filesize = 256M

date.timezone = America/Sao_Paulo

Reinicie os serviços NGINX e o PHP:

systemctl restart nginx && systemctl restart php8.1-fpm

Habilitar e Ajustar o OpCache

O OPcache é uma forma de acelerar seus scripts em PHP. Após um script PHP ser compilado para opcode, esse opcode é armazenado na memória para uso futuro. Quando um usuário acessa novamente esse script no seu site, o opcode já está disponível, não sendo necessário refazê-lo. Isso acelera a execução de scripts em PHP, deixando seu site mais rápido.

Deve-se então redefinir os parâmetros referentes ao bloco [opcache] no arquivo php.ini:

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

Algumas das diretivas a seguir, estão originalmente desabilitadas. Vamos então habilitar (retirando o ; na frente da diretiva) e definir valores para outras diretivas. Ajuste os seguintes campos para os valores sugeridos abaixo.

[opcache]
; Determines if Zend OPCache is enabled
opcache.enable=1

; Determines if Zend OPCache is enabled for the CLI version of PHP
opcache.enable_cli=0

; The OPcache shared memory storage size.
opcache.memory_consumption=128

; The amount of memory for interned strings in Mbytes.
opcache.interned_strings_buffer=8

; The maximum number of keys (scripts) in the OPcache hash table.
; Only numbers between 200 and 1000000 are allowed.
opcache.max_accelerated_files=10000

; The maximum percentage of "wasted" memory until a restart is scheduled.
opcache.max_wasted_percentage=5

; When this directive is enabled, the OPcache appends the current working
; directory to the script key, thus eliminating possible collisions between
; files with the same name (basename). Disabling the directive improves
; performance, but may break existing applications.
opcache.use_cwd=1

; When disabled, you must reset the OPcache manually or restart the
; webserver for changes to the filesystem to take effect.
opcache.validate_timestamps=1

; How often (in seconds) to check file timestamps for changes to the shared
; memory storage allocation. ("1" means validate once per second, but only
; once per request. "0" means always validate)
opcache.revalidate_freq=2

; Enables or disables file search in include_path optimization
opcache.revalidate_path=0

; If disabled, all PHPDoc comments are dropped from the code to reduce the
; size of the optimized code.
;opcache.save_comments=1

Reinicie os serviços NGINX e o PHP:

systemctl restart nginx && systemctl restart php8.1-fpm

Criar o arquivo phpinfo.php

A criação do arquivo phpinfo.php permite mostrar no navegador de internet, todas as informações sobre a versão do PHP, seus módulos e parâmetros utilizados. Para isso, criaremos um arquivo na pasta padrão do NGINX (/var/www/html).

nano /var/www/html/phpinfo.php

Coloque o seguinte conteúdo nesse arquivo e salve-o:

<?php
phpinfo();
?>

O usuário “www-data” é o padrão para operação normal em servidores Web com o NGINX. Deve-se então definir esse usuário como proprietário da pasta onde está localizado o seu arquivo:

chown -R www-data:www-data /var/www/html/

Defina as permissões corretas para a pasta:

chmod -R 755 /var/www/html/

Após, vá até o seu navegador web (Chrome, Firefox, Edge, etc.) e digite o seu respectivo endereço: http://<EndereçoIP>/phpinfo.php ou  http://localhost/phpinfo.php e a seguinte janela deve aparecer:

Instalar e configurar a base de dados MySQL (MariaDB):

O MariaDB é um sistema de gerenciamento de banco de dados de código aberto, usado com frequência como uma alternativa ao MySQL. No momento em que este tutorial está sendo escrito, os repositórios APT padrão do Ubuntu 22.04 incluem a versão 10.6.12 do MariaDB.

Proceda a instalação do MariaDB:

apt install mariadb-server mariadb-client

Após concluída a instalação, habilite para iniciar no boot e reinicie o MariaDB:

systemctl enable mariadb
systemctl restart mariadb

Confira a versão do MariaDB:

mariadb --version

Antes de criar a base de dados, vamos tornar o MariaDB mais seguro. Execute o comando a seguir e, quando solicitado, defina a “senha do usuário root do MariaDB”, remova o “usuário anônimo”, “mantenha o login remoto pelo usuário root do banco de dados” e exclua a base de dados “test”:

/usr/bin/mysql_secure_installation

Quando solicitado, responda às perguntas abaixo:

Enter current password for root (enter for none): Pressione Enter
Change the root password? [Y/n]: Digite Y
New password: Digite a senha do SGBD
Re-enter new password: Digite a senha novamente
Remove anonymous users? [Y/n]: Digite Y
Disallow root login remotely? [Y/n] : Digite Y
Remove test database and access to it? [Y/n]: Digite Y
Reload privilege tables now? [Y/n]: Digite Y 

Faça login ao servidor do banco de dados MariaDB com o respectivo usuário root e entre com a respectiva senha definida acima:

mysql -u root -p

Estando na interface de administração do MariaDB, crie a base de dados do seu site WordPress (ex: meuSiteDB):

create database [nomeDB] CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

Se você desejar que um outro usuário diferente do “root”, tenha acesso a base de dados recém criada, é necessário criar e depois associar um usuário para essa base de dados:

CREATE USER '[usuarioDB]'@'localhost' IDENTIFIED BY '[senhaUsuarioDB]';

Neste ponto, o usuário recém criado, não possui permissões para fazer nada com as base de dados, portanto, deve-se fornecer ao usuário o acesso às informações que eles irão precisar. No caso, vamos garantir todos os privilégios do banco de dados para o respectivo usuário:

GRANT ALL PRIVILEGES on [nomeDB].* to '[usuarioDB]'@'localhost' identified by '[senhaUsuarioDB]';

Atribua os respectivos privilégios:

flush privileges;

Saia da interface de administração do MariaDB:

exit

Instalação do PhpMyAdmin, para gerenciamento via web, das bases de dados

Execute o seguinte comando para instalar o phpmyadmin:

sudo apt-get install -y phpmyadmin

Na primeira tela que surgirá, teremos duas opções: apache2 e lighthttp. Como nós estamos utilizando o nginx como servidor web, não escolheremos nenhuma dessas opções. Pressione a tecla de tabulação (TAB) e confirme clicando em OK.

Na próxima tela que surge, de configuração de banco de dados (dbconfig-common), como já temos o banco de dados definido, não precisamos fazer essa configuração, escolha a opção No.

Se perguntado, informe a senha de seu usuário MySQL, definido acima.

Ajuste o PHPMyAdmin para o NGINX

sudo ln -s /usr/share/phpmyadmin /var/www/html

Reinicie o servidor NGINX

sudo systemctl restart nginx 

Agora, você pode acessar o phpmyadmin a partir de seu endereço IP (Ex: http://seuIP/phpmyadmin).

INSTALAÇÃO E CONFIGURAÇÃO DO WORDPRESS

Faça o download da última versão do WordPress na pasta padrão do NGINX:

Acesse a pasta “/var/www/html”:

cd /var/www/html

Faça o download da última versão do WordPress:

wget https://br.wordpress.org/latest-pt_BR.zip

Descompacte o arquivo recém baixado:

unzip latest-pt_BR.zip

Descompacte o arquivo recém baixado:

unzip latest.zip

Após descomapctado, mova a pasta recém criada (wordpress) para o nome do seu site (ex: meuSite)

mv wordpress <meuSite>

Apague o arquivo compactado recém baixado:

rm latest-pt_BR.zip

O usuário “www-data” é o padrão para operação normal para servidores Web como o NGINX. Defina esse usuário como proprietário da pasta do seu site WordPress:

chown -R www-data:www-data /var/www/html/<meuSite>

Defina as permissões corretas para o diretório raiz do seu site WordPress: 

chmod -R 755 /var/www/html/<meuSite>

Crie um site na configuração do NGINX:

Com as etapas realizadas até aqui, já é possível acessar o seu site WordPress via navegador web e iniciar o procedimento de instalação inicial, mas para uma melhor organização, para definir o domínio público de seu website (ex: www.meusite.com.br) e também ter a possibilidade de colocar múltiplos websites no mesmo servidor usando a mesma pilha LEMP, deve-se criar o respectivo arquivo de configuração.

Crie o arquivo “<meuSite>” na pasta “/etc/nginx/sites-available”:

nano /etc/nginx/sites-available/<meuSite>

Coloque o seguinte conteúdo, ajustando os campos relacionados ao seu site, de acordo com suas configurações:

server {
listen 80;
listen [::]:80;
root /var/www/html/<meuSite>;
index index.php index.html index.htm index.nginx-debian.html;
server_name <meuSite> www.<meuSite>;
client_max_body_size 100M;

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;
}
}

Teste o NGINX para conferir se não houve algum erro na edição desse arquivo:

nginx -t

A saída deve ser:

ginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Para finalizar esta etapa, deve-se definir o Host Virtual (Virtualhost) do site recém configurado. Para isso, basta criar uma ligação simbólica (comando “ln -s”) do respectivo arquivo de configuração para a subpasta “sites-enabled”:

ln -s /etc/nginx/sites-available/<meuSite> /etc/nginx/sites-enabled/

Teste o NGINX para conferir se não houve algum erro na edição desse arquivo:

nginx -t

A saída deve ser semelhante com a sintaxe a seguir:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Reinicie os serviços NGINX e o PHP:

systemctl restart nginx && systemctl restart php8.1-fpm

Se você estiver em um ambiente de desenvolvimento ou se ainda não tem o seu domínio, já é possível iniciar o procedimento de instalação do WordPress. No seu navegador web, digite o seu respectivo endereço: http://<EndereçoIP>/<meuSite> ou  http://localhost/<meuSite>.

Se desejar seguir com a instalação, defina na próxima tela, os dados do sua base de dados, definidos no item 4.5 deste documento.

INSTALAÇÃO DO CERTIFICADO DIGITAL

Para esta etapa, é fortemente recomendado um nome de domínio registrado, usaremos como referência o domínio <meuSite.com.br>. Você pode comprar um nome de domínio no registrador de domínios de sua escolha (ex: Registro.br, Cloudflare, Namecheap, etc.) ou obter um gratuitamente no site Freenom.

Instalaremos o Certbot do Let’s encrypt e seu plug-in do Nginx:

apt install certbot python3-certbot-nginx

O Certbot precisa conseguir encontrar o bloco de servidor correto na sua configuração NGINX para que ele seja capaz de configurar automaticamente o SSL. Mais especificamente, ele faz isso procurando uma diretiva “server_name” que corresponda ao domínio do qual você solicita um certificado. Em uma das etapas realizadas anteriormente, foi mostrada a criação do arquivo de configuração, onde temos o respectivo bloco e a respectiva diretiva já devidamente configurados.

Para verificar, abra o arquivo de configuração do seu domínio usando o nano ou seu editor de texto preferido:

nano /etc/nginx/sites-available/<meuSite>

Localize a linha existente server_name e ajuste o conteúdo de acordo com o nome de seu domínio:

...
server_name <meuSite.com.br> www.<meuSite.com.br>;
...

Se estiver correto, saia do seu editor e siga para o próxima etapa:

O Certbot oferece várias maneiras de obter certificados SSL através de plug-ins. O plug-in NGINX cuidará da reconfiguração do servidor web e recarregará a configuração sempre que necessário. Para usar este plug-in, digite o seguinte:

certbot --nginx -d <meuSite.com.br> -d www.<meuSite.com.br>

O comando acima executa o certbot com o plug-in nginx e usa o -d para especificar os nomes de domínio para os quais desejamos um certificado válido.

Se essa é a primeira vez que você executa o certbot, você será solicitado a informar um endereço de e-mail e concordar com os termos de serviço. Após fazer isso, o certbot se comunicará com o servidor da Let’s Encrypt, executando posteriormente um desafio para verificar se você controla o domínio para o qual está solicitando um certificado.

Se tudo estiver correto, o certbot perguntará como definir suas configurações de HTTPS. Escolha a opção 2 e pressione [Enter].

Output Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access.
Choose this for new sites, or if you're confident your site works on HTTPS. You can undo this change by editing your web server's configuration.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate number [1-2] then [enter] (press 'c' to cancel)> 2

A configuração será atualizada e o Nginx recarregará para aplicar as novas configurações. O certbot será encerrado com uma mensagem informando que o processo foi concluído e onde os certificados estão armazenados:

IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at: /etc/letsencrypt/live/<meuSite.com.br>/fullchain.pem
Your key file has been saved at: /etc/letsencrypt/live/<meuSite.com.br>/privkey.pem Your cert will expire on 2022-04-28.
To obtain a new or tweaked version of this certificate in the future, simply run certbot again with the "certonly" option.
To non-interactively renew *all* of your certificates, run "certbot renew" - If you like Certbot, please consider supporting our work by:
Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate Donating to EFF: https://eff.org/donate-le

Os certificados foram baixados, instalados e carregados. Tente recarregar o seu site usando https://<meuSite.com.br> e verifique o indicador de segurança do seu navegador. Ele deve indicar que o site está devidamente protegido, normalmente com um ícone de cadeado.

Faça também um teste no site SSL Labs Server Test​​​​, e você deverá receber uma classificação A.

Os certificados da Let’s Encrypt possuem validade de apenas 90 dias. O pacote certbot que instalamos cuida disso adicionando um temporizador systemd que será executado duas vezes por dia e renovará automaticamente qualquer certificado que esteja dentro de trinta dias da expiração.

Para consultar o status do temporizador com o systemctl:

sudo systemctl status certbot.timer

A saída deve ser semelhante a:

● certbot.timer - Run certbot twice daily
Loaded: loaded (/lib/systemd/system/certbot.timer; enabled; vendor preset: enabled)
Active: active (waiting) since Mon 2022-01-28 20:04:36 UTC; 1 days ago
Trigger: Thu 2022-01-28 05:22:32 UTC; 1h left
Triggers: ● certbot.service

Quando necessário, o Certbot renovará seus certificados e recarregará o NGINX para aplicar as alterações. Se o processo de renovação automatizada alguma vez falhar, a Let’s Encrypt enviará uma mensagem para o e-mail que você especificou, informando quando o certificado vai expirar.