How to build a Magento 2 e-commerce website on an ECS instance - Elastic Compute Service: Central de Documentação do Alibaba Cloud

Implante o Magento 2, uma plataforma de e-commerce open-source, em uma instância ECS com Ubuntu, NGINX, MySQL, OpenSearch e Composer.

Nota

Consulte o site oficial do Adobe Commerce para obter detalhes sobre o Magento 2.

Contexto

Este tópico utiliza uma instância ECS com as seguintes configurações:

Tipo de instância: ecs.c7.large
Sistema operacional: imagem pública Ubuntu 22.04 64 bits
CPU: 2 vCPUs
Memória: 4 GiB

Nota
O Magento 2 exige pelo menos 4 GiB de memória.

A documentação oficial do Magento 2 requer as seguintes versões de software:

Composer 2.7: gerencia a base de código do Magento 2 e as dependências de terceiros.
OpenSearch 2.12: fornece busca de produtos, incluindo filtragem e classificação por relevância.
MySQL 8.0: armazena dados comerciais, como produtos, pedidos e registros de clientes.
PHP 8.3: executa a lógica da aplicação e se comunica com bancos de dados e outros serviços.
NGINX 1.24: serve arquivos estáticos e atua como proxy reverso para requisições dinâmicas no PHP-FPM.

Pré-requisitos

Obtenha suas chaves pessoais no Adobe Commerce.
A instância ECS recebe automaticamente um endereço IP público. Como alternativa, associe um Elastic IP Address (EIP) à instância ECS. Para instruções sobre como ativar a largura de banda pública, consulte Ativar largura de banda pública.
Abra a porta 22 em uma regra de entrada do grupo de segurança. Consulte Adicionar uma regra de grupo de segurança.
Instale o Docker na instância ECS. Consulte Instalar o Docker.
Implante uma pilha LNMP (Linux, NGINX, MySQL e PHP). Consulte Implantar uma pilha LNMP.
Nota
- Versões necessárias: NGINX 1.24, MySQL 8.0 e PHP 8.3.
- Ajuste os números de versão nas etapas a seguir conforme necessário.

Procedimento

Etapa 1: Instale as extensões do PHP

Instale o pacote principal do PHP e as extensões.

Instale o pacote principal do PHP com as extensões integradas.

sudo apt-get install php8.3-cli php8.3-common php8.3-fpm php8.3-mysql php8.3-zip php8.3-gd php8.3-curl php8.3-intl php8.3-mbstring php8.3-soap php8.3-xml php8.3-bcmath php8.3-sqlite3 php8.3-opcache

Instale as extensões adicionais.

sudo apt-get install php8.3-bcmath php8.3-curl php8.3-gd php8.3-intl php8.3-mbstring php8.3-soap php8.3-xml php8.3-zip php8.3-sqlite3

Reinicie o NGINX para aplicar as alterações.
```
sudo systemctl restart nginx  
```

Configure o php.ini.

Abra os arquivos php.ini.

sudo vim /etc/php/8.3/fpm/php.ini
sudo vim /etc/php/8.3/cli/php.ini

Atualize as configurações abaixo, salve e feche os arquivos.

memory_limit = 2G
max_execution_time = 1800
zlib.output_compression = On

Reinicie o PHP-FPM.
```
sudo systemctl restart php8.3-fpm
```

Etapa 2: Crie um banco de dados do Magento 2

Conecte-se ao MySQL.
```
mysql -u root -p
```
Insira a senha de root do MySQL quando solicitado.

Crie e configure um banco de dados. Neste exemplo, tanto o banco de dados quanto o nome de usuário são magento.

CREATE DATABASE magento;
CREATE USER 'magento'@'localhost' IDENTIFIED BY 'magento';
GRANT ALL PRIVILEGES ON magento.* TO 'magento'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Verifique o banco de dados.
```
mysql -u magento -p
```
Nota
Se o monitor do MySQL aparecer, o banco de dados foi criado com sucesso. Caso ocorra um erro, execute novamente os comandos anteriores.

Etapa 3: Baixe e instale o OpenSearch

Antes de instalar o OpenSearch com Docker, conclua as tarefas a seguir:
1. Desative a paginação de memória e o swap para melhorar o desempenho.
```
sudo swapoff -a
```
2. Aumente o limite de mapeamento de memória para o OpenSearch.
  1. Abra o arquivo sysctl.conf.
```
sudo vi /etc/sysctl.conf
```
  2. Adicione vm.max_map_count=262144
  3. Verifique a configuração.
```
sudo sysctl -p
cat /proc/sys/vm/max_map_count
```

Execute o OpenSearch em um contêiner Docker.

Baixe a imagem do OpenSearch.

sudo docker pull opensearchproject/opensearch:2

Implante o OpenSearch em um contêiner para verificar se o Docker funciona corretamente.

sudo docker run -d \
 -p 9200:9200 \
 -p 9600:9600 \
 -e "discovery.type=single-node" \
 -e "OPENSEARCH_INITIAL_ADMIN_PASSWORD=admin" \
 -e "plugins.security.disabled=true" \
 opensearchproject/opensearch:latest

Nota

Este exemplo desativa o SSL nas camadas HTTP e Transport para testes, definindo plugins.security.disabled como true.

Envie uma requisição para a porta 9200. As credenciais padrão são admin/admin.

sudo curl -k http://localhost:9200 -ku admin:admin

Saída esperada:

{
  "name" : "a937e018****",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "GLAjAG6bTeWE****_d-CLw",
  "version" : {
    "distribution" : "opensearch",
    "number" : <version>,
    "build_type" : <build-type>,
    "build_hash" : <build-hash>,
    "build_date" : <build-date>,
    "build_snapshot" : false,
    "lucene_version" : <lucene-version>,
    "minimum_wire_compatibility_version" : "7.10.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "The OpenSearch Project: https://opensearch.org/"
}

Liste os contêineres em execução e copie o ID do contêiner do OpenSearch.
```
sudo docker container ls
```
Configure o NGINX como proxy para o OpenSearch.
1. Verifique se o arquivo /etc/nginx/nginx.conf contém include /etc/nginx/conf.d/*.conf;.
  
  vi /etc/nginx/nginx.conf
2. Crie a configuração de proxy.
  1. Crie o seguinte arquivo de configuração.
```
sudo vim /etc/nginx/conf.d/magento_es_auth.conf
```
```
server {
   listen 8080;
   location /_cluster/health {
      proxy_pass http://localhost:9200/_cluster/health;
   }
}
```
  2. Reinicie o NGINX.
```
sudo service nginx restart
```
  3. Verifique se o proxy está funcionando:
```
sudo curl -u admin:admin -i http://localhost:8080/_cluster/health?pretty
```
    Saída esperada:

Etapa 4: Baixe e instale o Composer

Instale as ferramentas de descompactação.

O Composer requer unzip ou p7zip para descompactação.
```
sudo apt-get install unzip
sudo apt-get install p7zip-full
```

Instale o Composer:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php -r "if (hash_file('sha384', 'composer-setup.php') === 'dac665fdc30fdd8ec78b38b9800061b4150413ff2e3b6f88543c636f7cd84f6db9189d43a81e5503cda447da73c7e5b6') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php
php -r "unlink('composer-setup.php');"

Mova o arquivo composer.phar para um diretório PATH visando o acesso global.
```
sudo mv composer.phar /usr/local/bin/composer
```
Verifique a versão do Composer.
```
composer --version
```

Etapa 5: Baixe e instale o Magento 2

Crie um projeto Composer usando o par de chaves de acesso obtido no Adobe Commerce. O nome do projeto é magento.

cd /var/www/html/
sudo composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition magento

Insira sua chave de autenticação quando solicitado.
Nota
- A chave de autenticação corresponde à chave privada obtida na seção Pré-requisitos.
- O download pode levar de 5 a 10 minutos.

Defina as permissões de arquivo.

cd /var/www/html/magento
find var generated vendor pub/static pub/media app/etc -type f -exec chmod g+w {} +
find var generated vendor pub/static pub/media app/etc -type d -exec chmod g+ws {} +
chown -R :www-data .
chmod u+x bin/magento

Instale o Magento 2.

Instale o Adobe Commerce pela linha de comando. Neste exemplo, db-host é localhost, e db-name, db-user e db-password são todos magento.

sudo bin/magento setup:install \
  --base-url=http://196.****.*.1/ \ # Public IP address of the ECS instance
  --db-host=localhost \ # Database host
  --db-name=magento \  # Database name
  --db-user=magento \ # Database username
  --db-password=magento \ # Database password
  --admin-firstname=admin \ # First name of the backend administrator
  --admin-lastname=admin \ 
  --admin-email=cy****sper@email.com \ # Administrator's email address
  --admin-user=admin \ # Backend login username
  --admin-password=admin*** \ # Backend login password
  --language=en_US \ # Website language
  --currency=USD \
  --timezone=America/Chicago \
  --use-rewrites=1 \
  --search-engine=opensearch \ 
  --opensearch-host=localhost \
  --opensearch-port=9200 \
  --opensearch-enable-auth=1 \
  --opensearch-username=admin \
  --opensearch-password=admin \
  --opensearch-index-prefix=magento2

Após a instalação, uma saída semelhante à seguinte será exibida.

A URI do Magento Admin é a URL do backend administrativo, acessível após a configuração do NGINX. Exemplo: http://47.****.**.72/admin_46i****.

Configure o encaminhamento do NGINX.

Crie um arquivo de configuração para o Magento 2.
```
sudo vim /etc/nginx/conf.d/magento.conf
```

Adicione o conteúdo abaixo, salve e saia.

upstream fastcgi_backend {
  server  unix:/run/php/php8.3-fpm.sock;
}
server {
  listen 80;
  server_name ip;
  set $MAGE_ROOT /var/www/html/magento;
  include /var/www/html/magento/nginx.conf.sample;
}

Verifique a sintaxe do NGINX.
```
nginx -t
```
Reinicie o NGINX.
```
sudo systemctl restart nginx
```

Acesse o site do Magento 2

Abra http://<Endereço IP público da sua instância ECS> no navegador para visualizar a página inicial padrão.
Acesse http://<Endereço IP público da instância ECS>/admin_46i**** e faça login com o nome de usuário admin e a senha admin***.

Perguntas frequentes

P1: O que fazer se eu não conseguir baixar o pacote de software do Magento 2?

Atualize o repositório de imagens para resolver esse problema.

Visualize o repositório de imagens atual.
```
composer config -l -g
```

Mude para um espelho do Alibaba Cloud.

sudo composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/

P2: Quais operações posso realizar em um nome de domínio?

Para usar um domínio personalizado no seu site, adquira um nome de domínio. Se sua instância ECS estiver localizada na China continental, solicite um registro ICP. Em seguida, resolva o nome de domínio para o endereço IP público da instância.

Adquira um nome de domínio.

Um nome de domínio oferece aos usuários um endereço fácil de memorizar em vez de um endereço IP.

Você pode registrar um nome de domínio no Alibaba Cloud.
Solicite um registro ICP para o nome de domínio.

O registro ICP é obrigatório para qualquer nome de domínio que aponte para um servidor em uma região da China continental. O site não ficará acessível publicamente até receber um número de registro ICP.
Resolva o nome de domínio.

Resolva o nome de domínio para o endereço IP da instância ECS usando o Alibaba Cloud DNS para que os usuários possam acessar seu site pelo domínio. Consulte Primeiros passos.

Elastic Compute Service:Build a Magento 2 e-commerce website on an Ubuntu instance