Deploy da GitHub, GitLab e immagini Docker

Deplomo PaaS ti permette di eseguire il deploy del codice sorgente e delle applicazioni senza gestire manualmente il sistema operativo del server. Questa guida spiega come eseguire il deploy da GitHub, collegare un’istanza GitLab self-hosted, distribuire un’immagine Docker, configurare la variabile PORT e impostare un monorepo. Per istruzioni specifiche per linguaggi e strumenti, consulta le guide al deploy .

Sorgenti dei servizi

Ogni servizio Deplomo usa una sorgente che determina come viene creata l’immagine del container:

1. Repository Git: esegui il deploy da GitHub o da un repository GitLab self-hosted. La piattaforma può rilevare automaticamente il framework oppure creare l’immagine da un Dockerfile.
2. Immagine Docker: esegui un’immagine da Docker Hub o da un registry privato.
3. Cartella locale tramite CLI: carica il codice locale con deplomo deploy.
4. Template del Marketplace: esegui il deploy da un template di un database supportato o di uno strumento open source.

1. Deploy da GitHub

Deplomo si collega a GitHub tramite la sua GitHub App. Non devi condividere password o chiavi SSH.

2. Collega un’istanza GitLab self-hosted

Se la tua organizzazione ospita il codice su un server GitLab self-hosted , puoi collegarlo a Deplomo:

1. Nella pagina di selezione della sorgente del progetto, scegli GitLab Self-hosted.
2. Inserisci l’URL completo dell’istanza GitLab, per esempio https://gitlab.company.com.
3. In GitLab crea un Personal Access Token con i permessi read_api e read_repository, poi inseriscilo nel campo corrispondente.
4. Dopo la convalida del token e il caricamento dell’elenco dei progetti, scegli il branch di deploy e attiva il webhook di sincronizzazione se vuoi automatizzare i deploy.

3. Esegui il deploy di un’immagine Docker

Usa un’immagine Docker se la tua pipeline CI/CD la crea già o se vuoi eseguire software commerciale o open source senza compilare il codice sorgente.

Deplomo scarica l’immagine dal registry e la esegue in un container con le risorse CPU e memoria assegnate al servizio. Per maggiori informazioni, consulta la pagina Container cloud .

Configura l’immagine

• Immagine e tag: usa un tag specifico, come my-app:v1.2.0. Evita latest in produzione: può cambiare tra un deploy e l’altro e rendere meno prevedibili i rollback.
• Registry privato: se l’immagine si trova in un registry che richiede l’autenticazione, inserisci il nome utente e il token di accesso. Le credenziali vengono salvate in forma cifrata sul server.
• Porta del container: imposta la porta su cui l’applicazione ascolta nel container, per esempio 80 o 8080, in modo che il traffico in ingresso raggiunga la porta corretta.

4. Rilevamento automatico del framework e build con Dockerfile

Dopo aver ricevuto il repository, Deplomo cerca i file che identificano il framework del progetto:

• Node.js: package.json
• Python: requirements.txt, Pipfile o pyproject.toml
• Go: go.mod
• PHP: composer.json
• Rust: Cargo.toml

Se il repository contiene un Dockerfile, la piattaforma lo usa per creare l’immagine dell’applicazione.

Per eseguire il deploy di una cartella locale dalla CLI o tramite un assistente AI, puoi aggiungere un file facoltativo deplomo.json per definire la porta, il comando di avvio e le variabili necessarie. Esegui deplomo check per individuare i problemi comuni prima del deploy. Per i dettagli, consulta il riferimento dei comandi CLI.

Monorepo

Non serve dividere un repository che contiene più applicazioni o pacchetti. Imposta Root Directory sulla cartella del servizio che vuoi distribuire. Per i dettagli di configurazione, consulta la guida al deploy dei monorepo .

5. La variabile d’ambiente PORT

Le applicazioni web e le API devono accettare il traffico in ingresso sulla porta specificata dalla variabile d’ambiente PORT. La piattaforma imposta questa variabile all’avvio del container.

Esempi: usa PORT nell’applicazione

Node.js (Express)

const express = require('express');
const app = express();
 
const port = process.env.PORT || 3000;
const host = '0.0.0.0';
 
app.listen(port, host, () => {
  console.log(`Server is running on http://${host}:${port}`);
});

Python (FastAPI con Uvicorn)

import os
import uvicorn
 
if __name__ == "__main__":
    port = int(os.environ.get("PORT", 8000))
    uvicorn.run("main:app", host="0.0.0.0", port=port)

Go

package main
 
import (
	"fmt"
	"net/http"
	"os"
)
 
func main() {
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	http.ListenAndServe("0.0.0.0:"+port, nil)
}

Confronta i metodi di deploy

Problemi comuni e verifiche

1. Il servizio non ascolta su PORT: se la build riesce ma il servizio non si avvia, verifica che l’applicazione ascolti su 0.0.0.0:$PORT.
2. Log di build e runtime: nel pannello, Build Logs mostra i download dei pacchetti e gli errori di compilazione; Runtime Logs mostra l’output standard dell’applicazione.
3. Variabili di build e runtime: imposta le variabili necessarie durante la build del frontend in Build-time Variables. Usa Runtime Variables per le credenziali del database e gli altri valori necessari solo a runtime.