Configurazione host

Questa pagina descrive la configurazione necessaria sul server GCP per ospitare il progetto.

Requisiti server

Risorsa	Minimo consigliato
CPU	2 vCPU
RAM	4 GB
Disco	30 GB SSD
OS	Ubuntu 22.04 LTS

1. Firewall GCP

Nella console GCP, verifica che la regola default-allow-ssh sia presente e attiva:

Porta: tcp:22
Sorgente: 0.0.0.0/0
Direzione: In entrata
Azione: Consenti

Questa regola permette alla pipeline GitHub Actions di connettersi via SSH per il deploy.

suggerimento

Per maggiore sicurezza in produzione, puoi restringere la sorgente agli IP di GitHub Actions invece di 0.0.0.0/0.

2. Installazione Docker

# Aggiorna i pacchetti
sudo apt-get update

# Installa Docker
curl -fsSL https://get.docker.com | sudo sh

# Aggiungi l'utente al gruppo docker (evita sudo)
sudo usermod -aG docker $USER
newgrp docker

# Verifica installazione
docker --version
docker compose version

3. Struttura cartelle deploy

Crea la cartella di lavoro per i file di deploy:

mkdir -p ~/deploy

Il workflow GitHub Actions copierà automaticamente in questa cartella:

.env
docker-compose.<env>.yml
deploy-with-profiles.sh

4. Configurazione DNS

Sul DNS provider (es. Cloudflare):

Record	Tipo	Valore
`rainty.app`	A	IP pubblico GCP
`*.rainty.app`	A	IP pubblico GCP (wildcard per Traefik)

L'IP pubblico del server si trova in GCP Console → Compute Engine → VM instances → colonna "IP esterno".

Per poter fare il pull delle immagini private durante il deploy:

docker login -u <DOCKERHUB_USERNAME>
# inserisci il token quando richiesto

Il login viene salvato in ~/.docker/config.json e resta valido per le sessioni future.

6. Traefik condiviso (obbligatorio se più progetti sullo stesso server)

Quando più progetti Docker girano sullo stesso server (es. trading-system + rainty), un solo processo può occupare le porte 80/443. La soluzione è un Traefik condiviso standalone che fa routing per hostname verso tutti i progetti.

Architettura

Internet
  ↓ :443
Traefik condiviso  ←── docker-compose.traefik.yml (avviato una volta)
  ├─ trading.expovin.it  →  trading-system containers  (rete traefik_web)
  └─ rainty.app          →  rainty containers           (rete traefik_web)

Ogni progetto:

non ha il proprio Traefik — il container Traefik è rimosso dal compose
espone i propri servizi sulla rete esterna traefik_web
mantiene la propria rete interna (project_net) per la comunicazione tra servizi

Setup sul server (una sola volta)

# 1. Crea la rete condivisa
docker network create traefik_web

# 2. Crea la struttura cartelle per il Traefik condiviso
mkdir -p ~/deploy/traefik/conf.d

# 3. Copia i file sul server
scp docker/docker-compose.traefik.yml utente@<IP_SERVER>:~/deploy/traefik/
scp docker/traefik-conf.d/example.yml utente@<IP_SERVER>:~/deploy/traefik/conf.d/

# 4. Avvia il Traefik condiviso
ssh utente@<IP_SERVER> \
  "cd ~/deploy/traefik && ACME_EMAIL=admin@rainty.app docker compose up -d"

warning

Il Traefik condiviso deve essere avviato prima di qualsiasi progetto. Non viene gestito dalla CI/CD — è una risorsa di infrastruttura del server.

Aggiungere un nuovo progetto

Non serve modificare il Traefik condiviso. Il nuovo progetto deve solo:

Connettere i propri servizi alla rete traefik_web nel docker-compose:

services:
  my-service:
    networks:
      - project_net   # rete interna del progetto
      - traefik_web   # rete condivisa per il routing esterno
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.my-service.rule=Host(`myprojekt.example.com`)"
      - "traefik.http.routers.my-service.entrypoints=websecure"
      - "traefik.http.routers.my-service.tls.certresolver=le"
      - "traefik.http.services.my-service.loadbalancer.server.port=3000"

networks:
  project_net:
    driver: bridge
  traefik_web:
    external: true

Usare middleware con prefisso specifico per il progetto (es. myproject-cors, myproject-auth) per evitare conflitti con altri progetti.

Traefik rileva i nuovi container automaticamente — nessun restart necessario.

Aggiungere route statiche o middleware globali (file provider)

Per route verso servizi non Docker, redirect, o middleware globali, crea un file YAML nella cartella ~/deploy/traefik/conf.d/ sul server. Traefik lo carica in tempo reale senza restart.

# Esempio: crea una route per un servizio esterno
nano ~/deploy/traefik/conf.d/mio-servizio.yml

Struttura del file (vedi docker/traefik-conf.d/example.yml per tutti gli esempi):

# Route verso un servizio non Docker (es. un processo sull'host)
http:
  routers:
    mio-servizio:
      rule: "Host(`mioservizio.example.com`)"
      entryPoints:
        - websecure
      tls:
        certResolver: le
      service: mio-servizio

  services:
    mio-servizio:
      loadBalancer:
        servers:
          - url: "http://127.0.0.1:8080"

I middleware definiti nei file conf.d/ sono accessibili da qualsiasi progetto Docker usando il suffisso @file invece di @docker:

- "traefik.http.routers.my-router.middlewares=my-global-middleware@file"

informazioni

La cartella conf.d/ sul server è la sola cosa da modificare per estendere il routing. Il file docker-compose.traefik.yml non va mai toccato dopo il primo avvio.

Migrazione da Traefik dedicato (trading-system)

Se trading-system ha già il proprio Traefik attivo sulla 443, prima di avviare il Traefik condiviso:

# Ferma il Traefik di trading-system
docker stop trading-traefik-1   # o il nome esatto del container

# Riavvia trading-system con il compose aggiornato (senza Traefik dedicato)
# I suoi servizi si collegheranno automaticamente a traefik_web

7. Verifica connettività SSH da GitHub Actions

Dopo aver configurato firewall e SSH key (vedi Variabili GitHub), puoi testare la connessione:

# Dal tuo PC locale con la stessa chiave SSH
ssh -o StrictHostKeyChecking=no utente@<IP_SERVER> "echo OK"

8. Avvio in locale (sviluppo)

In locale non c'è il Traefik condiviso del server. Il file docker-compose.local.yml aggiunge un Traefik locale su porte alternative per non collidere con altri processi:

Porta host locale	Porta container	Entrypoint Traefik
`8080`	`80`	`web` (HTTP)
`8443`	`443`	`websecure` (HTTPS)

# Prerequisito: crea la rete locale
docker network create traefik_web

# Avvio completo in locale
docker compose --env-file docker/.env.dev \
  -f docker/docker-compose.test.yml \
  -f docker/docker-compose.local.yml \
  -p test up -d

Per riavviare solo un singolo servizio (es. dopo un rebuild dell'immagine):

docker compose --env-file docker/.env.dev \
  -f docker/docker-compose.test.yml \
  -f docker/docker-compose.local.yml \
  -p test up -d --no-deps --force-recreate help

informazioni

Il file docker-compose.local.yml va sempre usato in aggiunta a quello test, non da solo. Sul server GCP si usa solo docker-compose.test.yml con il Traefik condiviso.

Requisiti server​

1. Firewall GCP​

2. Installazione Docker​

3. Struttura cartelle deploy​

4. Configurazione DNS​

5. Login DockerHub sul server​

6. Traefik condiviso (obbligatorio se più progetti sullo stesso server)​

Architettura​

Setup sul server (una sola volta)​

Aggiungere un nuovo progetto​

Aggiungere route statiche o middleware globali (file provider)​

Migrazione da Traefik dedicato (trading-system)​

7. Verifica connettività SSH da GitHub Actions​

8. Avvio in locale (sviluppo)​