Come distribuire Docker Compose Stack su Kubernetes con Kompose

Docker Compose ti consente di definire pile di contenitori che puoi gestire collettivamente. È uno strumento relativamente semplice che originariamente si concentrava sulle installazioni Docker locali.

Kubernetes è un orchestratore di contenitori che viene fornito con la propria toolchain e file manifest. Di solito è considerato più complesso di un normale flusso di lavoro Docker, ma le sue capacità facilitano le implementazioni di container scalabili in produzione.

Kompose è uno strumento che ti consente di prendere file Docker Compose e distribuirli su cluster Kubernetes. È sviluppato nell'ambito del progetto Kubernetes.

Le attuali versioni di Kompose sono limitate alle conversioni di file YAML. Devi applicare i manifesti delle risorse Kubernetes convertiti al tuo cluster utilizzando uno strumento come Kubectl. Le versioni precedenti di Kompose avevano un up integrato comando che potrebbe essere distribuito direttamente nel tuo cluster senza un passaggio di conversione intermedio. Questa è stata rimossa a causa della crescente complessità tecnica.

Per iniziare

Kompose è disponibile per Windows, macOS e le distribuzioni Linux più popolari. I binari predefiniti sono disponibili dal suo repository GitHub. Scarica l'ultima versione, imposta il bit di autorizzazione eseguibile e sposta il file binario in una directory che si trova nel tuo percorso. Sono supportati anche diversi gestori di pacchetti.

curl -L https://github.com/kubernetes/kompose/releases/download/v1.23.0/kompose-linux-amd64 -o kompose
chmod +x kompose
sudo mv ./kompose /usr/local/bin/kompose

Prova a eseguire kompose nel tuo terminale Vedrai alcune informazioni di base sui comandi disponibili. Esecuzione di kompose version controlla la versione di Kompose che stai utilizzando.

Ora assicurati di avere un docker-compose.yml file disponibile. Ecco un esempio di base che configura un server Web Apache con un database MySQL:

version: "3"

services:
  apache:
    image: httpd:latest
    ports:
      - 80:80
  mysql:
    image: mysql:latest
    expose:
      - 3306
    volumes:
      - mysql:/var/lib/mysql

volumes:
  mysql:

Hai anche bisogno di un cluster Kubernetes in cui eseguire la distribuzione. Crea un nuovo cluster con un provider di cloud pubblico o avvia il tuo utilizzando un progetto come MicroK8s.

Conversione del tuo stack

Il kompose convert accetta il percorso di un file Docker Compose ed emette manifesti di risorse Kubernetes equivalenti. Utilizza docker-compose.yml nella tua directory di lavoro quando non viene fornito alcun percorso. Sono accettati più file tramite -f bandiera.

kompose convert -f docker-compose.yml -f docker-compose-dev.yml

Vedrai alcune righe di output mentre Kompose scrive file manifest per ciascuna delle risorse nel tuo stack Compose. I singoli file vengono creati per ogni componente del tuo docker-compose.yml . Verranno inseriti nella tua directory di lavoro.

Ecco il risultato della conversione di docker-compose.yml mostrato sopra:

Per ciascuno dei servizi Compose è stata creata una distribuzione e un servizio Kubernetes. Queste risorse definiscono i Pod da creare e le relative regole di instradamento di rete.

Esiste anche un PersistentVolumeClaim per il contenitore MySQL. Questo rappresenta il volume configurato in docker-compose.yml , fornendo spazio di archiviazione persistente per il database MySQL che sopravvive a qualsiasi singolo Pod.

Se esamini i file YAML, vedrai che sono solo normali manifest Kubernetes compatibili con Kubectl. Ecco il apache-deployment.yaml convertito file:

apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    kompose.cmd: kompose convert
    kompose.version: 1.23.0 (bc7d9f4f)
  creationTimestamp: null
  labels:
    io.kompose.service: apache
  name: apache
spec:
  replicas: 1
  selector:
    matchLabels:
      io.kompose.service: apache
  strategy: {}
  template:
    metadata:
      annotations:
        kompose.cmd: kompose convert
        kompose.version: 1.23.0 (bc7d9f4f)
      creationTimestamp: null
      labels:
        io.kompose.service: apache
    spec:
      containers:
        - image: httpd:latest
          name: apache
          ports:
            - containerPort: 80
          resources: {}
      restartPolicy: Always
status: {}

Le spec della distribuzione è abbastanza simile alla definizione del contenitore Apache nell'originale docker-compose.yml . Nel caso di questo semplice servizio, è facilmente mappato su un oggetto Kubernetes. Il resto del file consiste principalmente nell'impostazione dei metadati, comprese le annotazioni specifiche di Kompose che ti consentono di identificare le risorse create con lo strumento.

Distribuzione nel tuo cluster

Distribuisci il set di file manifest nel solito modo con kubectl apply . È una buona idea salvarli in una directory separata nel tuo docker-compose.yml , in modo che kubectl non prova a selezionare anche quel file incompatibile.

kubectl apply .

Le risorse verranno fornite all'interno del tuo cluster. Potrebbero essere necessari alcuni minuti prima che i tuoi servizi vengano eseguiti. Ispeziona la tua distribuzione con kubectl get deployments . Quando il AVAILABLE la colonna mostra 1 , il tuo carico di lavoro dovrebbe essere accessibile.

Ora puoi aggiornare la tua distribuzione modificando i manifest generati e rieseguendo kubectl apply . Se desideri ridimensionare Apache su tre repliche, devi aprire apache-deployment.yaml , cambia le replicas campo a 3 e applica il manifest modificato.

Puoi anche continuare ad aggiornare il tuo file Docker Compose. Esegui kompose convert di nuovo per ottenere l'interpretazione Kubernetes più recente del suo contenuto, quindi riapplicare l'output al tuo cluster. Tieni presente che questo sovrascriverà tutte le modifiche che hai applicato manualmente da allora.

Limitazioni

Kompose di solito funziona bene con i file Docker Compose utilizzando le funzionalità e le migliori pratiche più comuni. Può creare container, esporre porte e fornire storage persistente tramite volumi.

Tuttavia, non tutte le conversioni saranno perfette. Alcune funzionalità di Compose non hanno un equivalente diretto nel mondo Kubernetes, mentre altre eseguiranno la mappatura in un modo che potrebbe non soddisfare le tue esigenze. L'uso di distribuzioni e servizi in questo esempio è uno di questi casi:se stavi distribuendo direttamente su Kubernetes, potresti utilizzare una regola Ingress per esporre il tuo servizio, ma questo non viene creato da Kompose. Le decisioni ponderate vengono risolte prendendo l'opzione più semplice.

Incontrerai anche problemi relativi ai volumi. I file Docker Compose possono associare file e cartelle di montaggio dall'host ai contenitori. Questo non è possibile con Kubernetes, quindi avrai bisogno di una soluzione alternativa. Inoltre, sebbene Kompose possa creare risorse per PersistentVolumeClaims, non creerà i PersistentVolumes effettivi. Dovrai disporre di un volume già disponibile all'interno del tuo cluster prima di provare a distribuire i manifesti.

Una tabella completa delle funzionalità supportate e dei dettagli di conversione è offerta come parte della documentazione di Kompose. Vale la pena verificare che le funzionalità Docker Compose che utilizzi siano supportate prima di iniziare qualsiasi operazione di conversione.

Conclusione

Kompose semplifica la migrazione da Docker Compose a un cluster Kubernetes. Automatizza passaggi che prima erano noiosi, dispendiosi in termini di tempo e soggetti a errori. È un buon ausilio, anche se non uno strumento che dovrebbe essere eseguito senza un certo grado di supervisione.

Le conversioni di Kompose non sono universalmente applicabili, quindi non saranno adatte a tutti gli ambienti. Vale sempre la pena controllare i manifest emessi prima di applicarli al tuo cluster. In alcuni casi, è meglio usare Kompose come riferimento:converti il ​​tuo docker-compose.yml , guarda qual è il risultato, quindi utilizzalo come punto di partenza per costruire manifest completamente compatibili con la tua applicazione e il tuo cluster.