Pular para o conteúdo principal

mtls

Configurando e configurando o certificado mTLS para a Plataforma 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. 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. 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. No seu painel, vá para a aba 'Acesso' e mude de token para mTLS.
  2. Gere um novo certificado no OneEntry ('Configurações' -> 'Certificados de Aplicação' -> 'Criar Novo Certificado').
  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. Baixe o arquivo setupProxy.js e salve-o na pasta 'src'.
  2. Edite o parâmetro 'target', especificando o endereço do seu projeto.
  3. Instale o pacote 'http-proxy-middleware': 'npm install http-proxy-middleware'.
  4. Inicie a aplicação.

Parte 2: Configuração do Servidor​

Preparando o Servidor​

  1. Atualize as informações do repositório: `apt update`.
  2. Adicione o repositório Docker e instale os pacotes: `apt install nginx certbot docker-ce pwgen`.

Configuração do UFW​

  1. Bloqueie todas as conexões de entrada: `ufw default deny incoming`.
  2. Permita todas as conexões de saída: `ufw default allow outgoing`.
  3. Permita conexões TCP de entrada nas portas 22, 80 e 443: `ufw allow 22,80,443/tcp`.

Configuração do SSH​

  1. Edite a configuração do daemon SSH: `nano /etc/ssh/sshd_config`.
  2. Defina `PasswordAuthentication no`.
  3. Reinicie o daemon SSH: `systemctl restart ssh`.

Configuração do Nginx​

  1. Remova o arquivo de configuração padrão: `rm /etc/nginx/sites-available/default`
  2. Crie um novo arquivo de configuração: `nano /etc/nginx/sites-available/my_app`.
  3. Baixe e edite a configuração do Nginx do OneEntry, substituindo "your_domain.com" pelo seu domínio.
  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. Emita certificados SSL usando o Certbot: `certbot certonly --webroot -w /var/www/html -d your_domain`
  6. Verifique a renovação automática do certificado: `certbot renew --dry-run`.
  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. 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. Verifique a configuração do Nginx: `nginx -t`
  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. Gere uma senha: 'pwgen -s 15 1'
  2. Crie um novo usuário: 'useradd -m github-runner'
  3. Defina uma senha para ele: 'passwd github-runner'
  4. Adicione o novo usuário aos grupos: 'usermod -aG docker github-runner' e 'usermod -aG sudo github-runner'.
  5. Altere o shell para o usuário GitHub Runner: 'chsh -s /bin/bash github-runner'
  6. Mude para o novo usuário: 'sudo su - gitlab-runner'.

Configurando o GitHub Runner​

  1. Crie um GitHub Runner: vá para as configurações do seu repositório, clique em 'Ações' e selecione 'Runners', em seguida clique em 'Novo runner auto-hospedado'.
  2. Siga as instruções no bloco 'Download' e o primeiro comando no bloco 'Configurar'.
  3. Adicione o Runner ao autostart do sistema: 'sudo ./svc.sh install'. Você precisará inserir a senha gerada anteriormente.
  4. Inicie o Runner: 'sudo ./svc.sh start'.
  5. Vá para a seção 'Ações', clique em 'Runners' e verifique se o 'Runner' está em execução.
  6. Volte para o usuário 'root'.
  7. Crie um diretório de trabalho: 'mkdir -p /var/apps/frontend'
  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. 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. 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. Baixe o arquivo docker-compose.yml e dois arquivos .github e .docker.
  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. Execute o comando de push no seu projeto.
  6. Verifique o processo na aba 'Ações'.
  7. Verifique a acessibilidade da aplicação no navegador.
GitLab

Registrando o GitLab Runner​

  1. Especifique as tags 'docker, frontend'.
  2. Vá para 'Configurações -> CI/CD -> Runners' e clique no botão 'Novo runner de projeto'.
  3. Vá para o diretório criado: `cd /var/apps/gitlab-runner`.
  4. Execute o comando para iniciar o processo de registro: `docker compose run runner register`.
  5. Insira a URL do GitLab, por exemplo, https://gitlab.com/.
  6. Obtenha o token de registro do GitLab (na seção 'Runners' do projeto) e cole-o no terminal.
  7. Especifique o executor como 'docker'.
  8. Especifique a imagem padrão como docker:20.10.16.

Configurando variáveis de ambiente no GitLab​

  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. 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. 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. Crie os diretórios necessários: `mkdir -p /var/apps/gitlab-runner/volumes/etc/gitlab-runner`
  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. Edite o arquivo de configuração: `nano volumes/etc/gitlab-runner/config.toml`.
  2. Defina o parâmetro `priviledged` como `true` para habilitar Docker-in-Docker.
  3. Altere o valor de `volumes` para `['/var/run/docker.sock:/var/run/docker.sock', '/cache']` para que o Docker funcione corretamente.
  4. Adicione `user = 'gitlab-runner'` no início do arquivo para executar o Runner como esse usuário.
  5. Salve as alterações e saia do editor.
  6. Reinicie o Runner: 'systemctl restart gitlab-runner'.

Ativando e verificando o GitLab Runner​

  1. Execute o comando `docker compose up -d` para iniciar o Runner.
  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. Siga as Instruções para instalar um Runner adicional que roda diretamente no host (não no Docker).
  2. Defina tags para o Runner: 'shell, frontend'.

Permissões do Runner​

  1. Adicione um novo usuário ao grupo: 'usermod -aG docker gitlab-runner'
  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. Certifique-se de que todos os Runners estão devidamente configurados e prontos para uso.
  2. Execute o comando de push no seu projeto.
  3. Verifique o progresso em 'Build' -> 'Pipelines'.
  4. Verifique a disponibilidade da aplicação no navegador.

Conclusão​

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