Pular para o conteúdo principal

mtls

Configuração e configuração do certificado mTLS para Headless CMS OneEntry usando tokens e mTLS, além de implantar a aplicação em um servidor com Nginx, Docker e GitLab

Parte 1: Configurando mTLS​

Protegendo a API​
  1. 1. Usando Token: Gere um token nas configurações do OneEntry e adicione-o aos cabeçalhos da solicitação com o parâmetro 'x-app-token', onde o valor é o token.
  2. 2. Usando mTLS: Ative a opção mTLS no seu painel do OneEntry e gere o certificado nas configurações do OneEntry.
Configurando o certificado​
  1. 1. No seu painel, vá para a aba 'Acesso' e mude de token para mTLS.
  2. 2. Gere um novo certificado no OneEntry ('Configurações' -> 'Certificados de Aplicação' -> 'Criar Novo Certificado').
  3. 3. Baixe-o para o seu computador e extraia-o para a pasta 'cert' na raiz do seu projeto.
Configurando o ambiente local (usando ReactJS como exemplo)​
  1. 1. Baixe o arquivo setupProxy.js e salve-o na pasta 'src'.
  2. 2. Edite o parâmetro 'target', especificando o endereço do seu projeto.
  3. 3. Instale o pacote 'http-proxy-middleware': 'npm install http-proxy-middleware'.
  4. 4. Inicie a aplicação.

Parte 2: Configuração do Servidor​

Preparando o Servidor​
  1. 1. Atualize as informações do repositório: `apt update`.
  2. 2. Adicione o repositório Docker e instale os pacotes: `apt install nginx certbot docker-ce pwgen`.
Configuração do UFW​
  1. 1. Bloqueie todas as conexões de entrada: `ufw default deny incoming`.
  2. 2. Permita todas as conexões de saída: `ufw default allow outgoing`.
  3. 3. Permita conexões TCP de entrada nas portas 22, 80 e 443: `ufw allow 22,80,443/tcp`.
Configuração do SSH​
  1. 1. Edite a configuração do daemon SSH: `nano /etc/ssh/sshd_config`.
  2. 2. Defina `PasswordAuthentication no`.
  3. 3. Reinicie o daemon SSH: `systemctl restart ssh`.
Configuração do Nginx​
  1. 1. Remova o arquivo de configuração padrão: `rm /etc/nginx/sites-available/default`.
  2. 2. Crie um novo arquivo de configuração: `nano /etc/nginx/sites-available/my_app`.
  3. 3. Baixe e edite a configuração do Nginx do OneEntry, substituindo "your_domain.com" pelo seu domínio.
  4. 4. Em seguida, execute o comando: ‘ln -s /etc/nginx/sites-available/my_app /etc/nginx/sites-enabled', substituindo "my_app" pelo nome do seu arquivo de configuração.
  5. 5. Emita certificados SSL usando o Certbot: `certbot certonly --webroot -w /var/www/html -d your_domain`.
  6. 6. Verifique a renovação automática do certificado: `certbot renew --dry-run`.
  7. 7. Edite a tarefa cron do Certbot para recarregar automaticamente a configuração do Nginx após a emissão dos certificados: ‘nano /etc/cron.d/certbot', substituindo a última linha por: `echo "0 */12 * * * root certbot -q renew && nginx -s reload" > /etc/cron.d/certbot`.
  8. 8. Descomente as linhas no arquivo de configuração 'nano /etc/nginx/sites-available/my_app' (onde 'my_app' é o nome do seu arquivo de configuração).
  9. 9. Verifique a configuração do Nginx: `nginx -t`.
  10. 10. Recarregue o Nginx após cada alteração: `nginx -s reload`.

Parte 3: Implantando a Aplicação com GitLab e GitHub​

GitHub
Criando um novo usuário para o GitHub Runner​
  1. 1. Gere uma senha: 'pwgen -s 15 1'.
  2. 2. Crie um novo usuário: 'useradd -m github-runner'.
  3. 3. Defina uma senha para ele: 'passwd github-runner'.
  4. 4. Adicione o novo usuário aos grupos: 'usermod -aG docker github-runner' e 'usermod -aG sudo github-runner'.
  5. 5. Altere o shell para o usuário GitHub Runner: 'chsh -s /bin/bash github-runner'.
  6. 6. Mude para o novo usuário: 'sudo su - gitlab-runner'.
Configurando o GitHub Runner​
  1. 1. Crie um GitHub Runner: vá para as configurações do seu repositório, clique em 'Ações' e selecione 'Runners', depois clique em 'Novo runner auto-hospedado'.
  2. 2. Siga as instruções no bloco 'Download' e o primeiro comando no bloco 'Configurar'.
  3. 3. Adicione o Runner ao autostart do sistema: 'sudo ./svc.sh install'. Você precisará inserir a senha gerada anteriormente.
  4. 4. Inicie o Runner: 'sudo ./svc.sh start'.
  5. 5. Vá para a seção 'Ações', clique em 'Runners' e verifique se o 'Runner' está em execução.
  6. 6. Volte para o usuário 'root'.
  7. 7. Crie um diretório de trabalho: 'mkdir -p /var/apps/frontend'.
  8. 8. Defina permissões para o usuário 'github-runner': 'chown -R github-runner:docker /var/apps/frontend'.
Configurando variáveis de ambiente no GitHub​
  1. 1. Crie as variáveis `DOMAIN`, `MTLS_USER_CERT` e `MTLS_USER_KEY` no seu repositório do GitHub ('Configurações' -> 'Segredos e Variáveis').
  2. 2. Gere um certificado no OneEntry, adicione o certificado e a chave às variáveis. Na variável `DOMAIN`, especifique o endereço do seu projeto sem https.
  3. 3. Baixe o arquivo docker-compose.yml e dois arquivos .github e .docker.
  4. 4. Coloque docker-compose.yml, .github.zip e .docker.zip na pasta raiz do seu projeto e extraia os arquivos (você pode excluir os arquivos após a extração).
  5. 5. Execute o comando de push no seu projeto.
  6. 6. Verifique o processo na aba 'Ações'.
  7. 7. Verifique a acessibilidade da aplicação no navegador.
GitLab
Registrando o GitLab Runner​
  1. 1. Especifique as tags 'docker, frontend'.
  2. 2. Vá para 'Configurações -> CI/CD -> Runners' e clique no botão 'Novo runner de projeto'.
  3. 3. Vá para o diretório criado: `cd /var/apps/gitlab-runner`.
  4. 4. Execute o comando para iniciar o processo de registro: `docker compose run runner register`.
  5. 5. Insira a URL do GitLab, por exemplo, https://gitlab.com/.
  6. 6. Obtenha o token de registro do GitLab (na seção 'Runners' do projeto) e cole-o no terminal.
  7. 7. Especifique o executor como 'docker'.
  8. 8. Especifique a imagem padrão como docker:20.10.16.
Configurando variáveis de ambiente no GitLab​
  1. 1. Crie as variáveis `DOMAIN`, `MTLS_USER_CERT` e `MTLS_USER_KEY` no seu repositório do GitLab ('Configurações' -> 'CI/CD' -> 'Variáveis').
  2. 2. Gere um certificado no OneEntry, adicione o certificado e a chave às variáveis e especifique o endereço do seu projeto sem https na variável `DOMAIN`.
  3. 3. Baixe os arquivos docker-compose.yml, .gitlab-ci.yml e o arquivo .docker, coloque os arquivos na raiz do seu projeto e descompacte os arquivos (você pode excluir os arquivos após a descompactação).
Preparando a configuração do GitLab Runner (executor Docker)​
  1. 1. Crie os diretórios necessários: `mkdir -p /var/apps/gitlab-runner/volumes/etc/gitlab-runner`.
  2. 2. Execute o comando: `cat \ /var/apps/gitlab-runner/docker-compose.yamlversion: '3' services: runner: image: 'gitlab/gitlab-runner:v16.2.0' restart: always container_name: 'gitlab-runner' privileged: true volumes: - './volumes/etc/gitlab-runner:/etc/gitlab-runner' - '/var/run/docker.sock:/var/run/docker.sock' EOT`.
Configuração do GitLab Runner​
  1. 1. Edite o arquivo de configuração: `nano volumes/etc/gitlab-runner/config.toml`.
  2. 2. Defina o parâmetro `priviledged` como `true` para habilitar Docker-in-Docker.
  3. 3. Altere o valor de `volumes` para `['/var/run/docker.sock:/var/run/docker.sock', '/cache']` para que o Docker funcione corretamente.
  4. 4. Adicione `user = 'gitlab-runner'` no início do arquivo para executar o Runner como esse usuário.
  5. 5. Salve as alterações e saia do editor.
  6. 6. Reinicie o Runner: 'systemctl restart gitlab-runner'.
Ativando e verificando o GitLab Runner​
  1. 1. Execute o comando `docker compose up -d` para iniciar o Runner.
  2. 2. Vá para o GitLab e verifique se o Runner está ativo e em execução (você deve ver seu status na seção 'Runners' do projeto).
Configurando um Runner adicional no host (executor shell)​
  1. 1. Siga as Instruções para instalar um Runner adicional que roda diretamente no host (não no Docker).
  2. 2. Defina tags para o Runner: 'shell, frontend'.
Permissões do Runner​
  1. 1. Adicione um novo usuário ao grupo: 'usermod -aG docker gitlab-runner'.
  2. 2. Se precisar alterar o proprietário e os grupos de um arquivo ou diretório: 'chown -R gitlab-runner:docker /var/apps/frontend'.

Configuração Final e Testes​

  1. 1. Certifique-se de que todos os Runners estão devidamente configurados e prontos para uso.
  2. 2. Execute o comando de push no seu projeto.
  3. 3. Verifique o progresso em 'Build' -> 'Pipelines'.
  4. 4. Verifique a disponibilidade da aplicação no navegador.

Conclusão​

Siga estes passos para uma configuração e implantação bem-sucedidas da sua aplicação com o OneEntry. Boa sorte com o desenvolvimento!