Configuração inicial do servidor

Atualizar o servidor

sudo apt update && sudo apt upgrade -y

Configurar hostname

sudo hostnamectl set-hostname vps.rodrigor.com

• Edite /etc/hosts
• Adicione 127.0.1.1       vps.rodrigor.com
• systemctl restart systemd-hostnamed

Definir timezone

sudo timedatectl set-timezone America/Recife
timedatectl # verificar timezone e data

Instalar pacotes básicos:

apt install -y curl wget git vim ufw htop
apt install net-tools -y
apt install apache2-utils -y

Criar usuário e grupo de manutenção

Este usuário é usado para: - acessar a pasta /srv e subdiretorios - atualizar o git em /srv/ - sua chave ssh é usada para os Github Actions acessarem o servidor e reiniciarem os serviços docker.

Usuários administradores do servidor também devem estar no grupo maintainer se quiserem ter permissão para atualizar os scripts e documentação do servidor.

sudo groupadd maintainer
sudo useradd -m -s /bin/bash -g maintainer maintainer
sudo usermod -s /usr/sbin/nologin maintainer # maintainer só loga usando chave ssh
sudo mkdir -p /home/maintainer/.ssh
sudo chmod 700 /home/maintainer/.ssh
sudo chown maintainer:maintainer /home/maintainer/.ssh

• Configurar chaves para serem usadas pelo Github Actions:

sudo -u maintainer ssh-keygen -t rsa -b 4096 -C "github_actions@vps.rodrigor.com" -f /home/maintainer/.ssh/id_rsa
sudo -u maintainer touch /home/maintainer/.ssh/authorized_keys
sudo chmod 600 /home/maintainer/.ssh/authorized_keys
sudo -u maintainer cat /home/maintainer/.ssh/id_rsa.pub >> /home/maintainer/.ssh/authorized_keys
sudo chmod 600 /home/maintainer/.ssh/authorized_keys

No [[config_github_actions]] use o conteúdo de /home/maintainer/.ssh/id_rsa para o secret SSH_PRIVATE_KEY

Adicionar primeiros usuários e adicioná-los como sudoers

manut-adicionar_usuario_admin

Configurar SSHD

Edite /etc/ssh/sshd_config

Defina os valores:

Port 2222
PermitRootLogin no
PubkeyAuthentication yes
PermitEmptyPasswords no
X11Forwarding no
PermitTunnel yes

• Verifique se a configuração está OK:

sudo sshd -t

• Reinicie o serviço ssh:

systemctl restart ssh

Config inicial do firewall

• Configurar firewall para aceitar conexões ssh na porta 2222:

sudo ufw allow 2222

• Ativar o firewall:

sudo ufw enable

• Verificar regras ativas no firewall:

sudo ufw status verbose

Configurar chave ssh para usuários

mkdir -p ~/.ssh
chmod 700 ~/.ssh

No computador onde vai acessar o servidor:

ssh-keygen -t rsa -b 4096 -C "seu_email@exemplo.com"

ssh-copy-id <username>@host # inserir o ip ou dns do host

Instalar Certbot

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx

Para testar se a renovação funciona:

sudo certbot renew --dry-run

Instalar o docker e o docker-compose

sudo apt update
sudo apt upgrade -y
sudo apt install -y docker.io
sudo systemctl start docker
sudo systemctl enable docker

• Instalar docker-compose:

sudo apt install -y docker-compose
sudo usermod -aG docker $(whoami) # dar permissões para usuário executar docker
sudo mkdir -p /srv/docker/

• Adicionar usuário maintainer no grupo docker, para executar ações no docker / docker-compose: (usado para os github_actions)

sudo usermod -aG docker maintainer

Configurar diretorio /srv/

sudo mkdir -p /srv/
sudo chown maintainer:maintainer /srv
sudo chmod 770 /srv/
sudo chmod g+s /srv/

Configurar repositório git em /srv

Este respositório armazena scripts e arquivos docker-compose para o servidor. - Inicializar o repositório git:

cd /srv
git init --initial-branch=main
git config --global init.defaultBranch main
git config --global --add safe.directory /srv

sudo mkdir -p /srv/.ssh
sudo chmod 700 /srv/.ssh
sudo chown -R maintainer:maintainer /srv/.ssh

• crie /srv/.ssh/config com o seguinte conteúdo:

Host github.com
    HostName github.com
    User git
    IdentityFile /srv/.ssh/git_key
    IdentitiesOnly yes

• crie /srv/git-wrapper.sh com o seguinte conteúdo:

#!/bin/bash
ssh -i /srv/.ssh/git_key -o IdentitiesOnly=yes "$@"

• dê permissão de execução e configure o git para executar o git-wrapper.sh:

sudo chmod +x /srv/git-wrapper.sh
git config --global core.sshCommand "/srv/git-wrapper.sh"

• Com um usuário do grupo maintainer: gerar um par de chaves para o repositório:

ssh-keygen -t rsa -b 4096 -C "maintainer@vps.rodrigor.com" -f /srv/.ssh/git_key
sudo chmod 640 /srv/.ssh/git_key

• Adicione a chave pública ao Github

cat /srv/.ssh/git_key.pub

Instalar Nginx

sudo apt install nginx -y

• criar configuração para vps.rodrigor.com: /etc/nginx/sites-available/vps.rodrigor.com:

server {
    listen 80;
    server_name vps.rodrigor.com www.vps.rodrigor.com;

    root /var/www/html;
    index index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }
}

• Criar link simbólico para sites-enabled e desabilite o site padrão:

sudo ln -s /etc/nginx/sites-available/vps.rodrigor.com /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default

• Verifique se a configuração está ok e reinicie o serviço do nginx:

sudo nginx -t
sudo systemctl restart nginx

• Liberar portas 80 e 443 no firewall:

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

• Solicite certificado ssl:

sudo certbot --nginx -d vps.rodrigor.com -d www.vps.rodrigor.com

• Definir página inicial do servidor
  • copie index.html para /var/www/html

Ativar serviço do mkdocs para site de documentação

• revise docker-compose em /srv/doc
• inicie o serviço: docker-compose up -d
• crie o subdominio doc.vps.rodrigor.com
• configure o proxy do serviço usando o script:

sudo /srv/admin/scripts/configure_proxy.sh doc.vps.rodrigor.com 9010

Proteger a documentação com um usuário htaccess

• criar o usuário docuser:

sudo htpasswd -c /srv/doc/.htaccess docuser

• editar /etc/nginx/sites-available/doc.vps.rodrigor.com e incluir em location /:

    location / {

        auth_basic "Acesso Restrito";

        auth_basic_user_file /srv/admin/.htaccess;

• Garanta que os diretórios /srv/, /srv/doc estão com permissão o+xr para que o usuário do nginx consiga acessar o arquivo .htaccess.

Instalar serviços básicos

• Portainer
• PGAdmin

TO DO:

• Instalar Grafana
• Instalar Prometheus
• Instalar Cadvisor
• Instalar Node Exporter
• Configurar um serviço com github actions

(não fiz nada a partir daqui)

---

Configurar Grafana e Prometheus com cAdvisor

Criar rede de monitoramento:

docker network create monitoring_net

Se quiser verificar que serviços estão conectados à rede:

docker network inspect monitoring_net

Descrição: - Cria uma rede dedicada para monitoramento e verifica os serviços conectados a ela.

---

Configurar Node Exporter

Node Exporter expõe métricas sobre o host para o Prometheus.

Instalado em /srv/local/node_exporter:

sudo mkdir -p /srv/local/node_exporter
cd /srv/local/node_exporter
sudo wget https://github.com/prometheus/node_exporter/releases/download/v1.8.2/node_exporter-1.8.2.linux-amd64.tar.gz
sudo tar xvfz node_exporter-1.8.2.linux-amd64.tar.gz
sudo mv node_exporter-1.8.2.linux-amd64/* .
sudo rm -rf node_exporter-1.8.2.linux-amd64.tar.gz node_exporter-1.8.2.linux-amd64

sudo chown -R root:root /srv/local/node_exporter
sudo chmod -R 755 /srv/local/node_exporter

Descrição: - Cria o diretório /srv/local/node_exporter para armazenar os arquivos do Node Exporter. - Baixa o binário mais recente do Node Exporter. - Extrai os arquivos, move para o diretório adequado e ajusta as permissões de forma que apenas o root tenha controle.

---

Configurar o arquivo de serviço para o Node Exporter:

sudo vim /etc/systemd/system/node_exporter.service

com o conteúdo:

[Unit]
Description=Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=root
ExecStart=/srv/local/node_exporter/node_exporter --web.listen-address=0.0.0.0:9100
Restart=always

[Install]
WantedBy=multi-user.target

Descrição: - Define um serviço systemd para o Node Exporter. - Configura o serviço para ser iniciado automaticamente no boot e reiniciar em caso de falha. - Define o endereço de escuta para todas as interfaces (0.0.0.0:9100).

---

Ativar o serviço:

sudo systemctl daemon-reload
sudo systemctl enable node_exporter
sudo systemctl start node_exporter
sudo systemctl status node_exporter

Descrição: - Atualiza a lista de serviços com daemon-reload. - Habilita o Node Exporter para iniciar no boot. - Inicia o serviço e verifica o status para garantir que está em execução.

---

Alterar o arquivo /srv/docker/prometheus/prometheus.yml para incluir o Node Exporter:

(considere que o cAdvisor já está configurado):

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']
  - job_name: 'node_exporter'
    static_configs:
      - targets: ['gateway:9100']

Descrição: - Configura o Prometheus para coletar métricas do Node Exporter na porta 9100 e do cAdvisor na porta 8080. - Define o intervalo de coleta (scrape_interval) como 15 segundos.

---

Configurar o arquivo docker_compose.yml para o Prometheus:

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
    ports:
      - "127.0.0.1:9097:9090"
    restart: unless-stopped
    extra_hosts:
      # O alias "gateway" aponta para o IP do gateway da rede Docker.
      # É necessário para que o prometheus consiga acessar o node_exporter,
      # na porta 9100. Verifique o arquivo prometheus.yml
      # Para descobrir o IP do gateway, execute:
      # docker network inspect monitoring_net | grep Gateway
      - "gateway:172.23.0.1"
    networks:
      - monitoring_net

networks:
  monitoring_net:
    external: true

Descrição: - Define o serviço Prometheus no Docker Compose. - Inclui o arquivo de configuração do Prometheus (prometheus.yml) como volume. - Conecta o serviço à rede monitoring_net, permitindo comunicação com outros serviços conectados.

---

Não permitir acesso externo ao Node Exporter, apenas localhost:

sudo ufw deny 9100

sudo ufw allow from 127.0.0.1 to any port 9100
sudo ufw allow from <ip do gateway> to any port 9100

sudo ufw status

Descrição: - Bloqueia o acesso à porta 9100 de interfaces externas. - Permite conexões apenas do localhost e do IP do gateway Docker.

---

Para identificar o <ip do gateway>:

docker network inspect monitoring_net | grep Gateway

Descrição: - Obtém o IP do gateway da rede monitoring_net para configurar corretamente as permissões do firewall.