web-dev-qa-db-fra.com

Kubernetes peut-il être utilisé comme Docker Compose?

Je fouille dans la documentation de Kubernetes depuis des heures. Je comprends la conception de base et la notion de services, de contrôleurs, de modules, etc.

Ce que je ne comprends pas, cependant, est le processus dans lequel je peux configurer le cluster de manière déclarative. C’est un moyen pour moi d’écrire un fichier de configuration (ou un ensemble de celui-ci) pour définir la composition et les options de mise à l’échelle du déploiement en nuage. Je veux pouvoir déclarer quels conteneurs je veux dans quels pods, comment ils vont communiquer, comment ils vont évoluer, etc. sans exécuter une tonne de commandes cli.

Existe-t-il une fonctionnalité docker-compose pour Kubernetes?

Je souhaite que mon application soit définie dans git, à contrôler sa version, sans recourir à des interactions cli manuelles.

Est-ce possible de le faire de manière concise? Existe-t-il une référence plus claire que la documentation officielle?

dockerkubernetesdocker-composegoogle-kubernetes-engine
57
Don Scott

Docker a officiellement annoncé le docker-compose fonctionnalité pour le cluster kubernetes. Donc, à partir de maintenant, vous pouvez composer les ressources kubernetes dans un fichier et les appliquer en utilisant ce fichier unique.

Nous devons d’abord installer le contrôleur Compose on Kubernetes dans votre cluster Kubernetes. Ce contrôleur utilise les points d’extension Kubernetes standard pour introduire le Stack à l’API Kubernetes. Consultez la documentation complète pour installer le contrôleur de composition de docker:

https://github.com/docker/compose-on-kubernetes

Ecrivons un simple fichier yaml:

version: "3.7"
services:
  web:
    image: dockerdemos/lab-web
    ports:
     - "33000:80"
  words:
    image: dockerdemos/lab-words
    deploy:
      replicas: 3
      endpoint_mode: dnsrr
  db:
    image: dockerdemos/lab-db

Nous utiliserons ensuite le client Docker pour le déployer sur un cluster Kubernetes exécutant le contrôleur:

$ docker stack deploy --orchestrator=kubernetes -c docker-compose.yml words
Waiting for the stack to be stable and running...
db: Ready       [pod status: 1/1 ready, 0/1 pending, 0/1 failed]
web: Ready      [pod status: 1/1 ready, 0/1 pending, 0/1 failed]
words: Ready    [pod status: 1/3 ready, 2/3 pending, 0/3 failed]
Stack words is stable and running

Nous pouvons ensuite interagir avec ces objets via l'API Kubernetes. Vous pouvez voir ici que nous avons créé automatiquement les objets de niveau inférieur tels que Services, Pods, Deployments et ReplicaSets:

$ kubectl get deployments
NAME                    DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/db      1         1         1            1           57s
deployment.apps/web     1         1         1            1           57s
deployment.apps/words   3         3         3            3           57s

Il est important de noter que cette conversion n’est pas unique. Le serveur API Compose on Kubernetes introduit la ressource Stack dans l'API Kubernetes. Nous pouvons donc interroger et gérer tout au même niveau d’abstraction que lors de la construction de l’application. Il est donc utile de fouiller dans les détails ci-dessus pour comprendre le fonctionnement des choses ou résoudre les problèmes de débogage, mais ce n’est pas nécessaire la plupart du temps:

$ kubectl get stack
NAME      STATUS      PUBLISHED PORTS   PODS     AGE      
words     Running     33000             5/5      4m
8
Prafull Ladha

Si vous cherchez toujours, cet outil peut peut-être vous aider: https://github.com/kelseyhightower/compose2kube

Vous pouvez créer un fichier de composition:

# sample compose file with 3 services
web:
  image: nginx
  ports:
    - "80"
    - "443"
database:
  image: postgres
  ports:
    - "5432"
cache:
  image: memcached
  ports:
    - "11211"

Puis utilisez l'outil pour le convertir en objets kubernetes:

compose2kube -compose-file docker-compose.yml -output-dir output

Qui va créer ces fichiers:

output/cache-rc.yaml
output/database-rc.yaml
output/web-rc.yaml

Ensuite, vous pouvez utiliser kubectl pour les appliquer aux kubernetes.

33
Ahmad Aabed

Si vous avez déjà des fichiers Docker Composer, vous pouvez consulter le projet Kompose .

kompose est un outil destiné à aider les utilisateurs familiarisés avec Docker-Composition à migrer vers Kubernetes. kompose prend un fichier Docker Compose et le traduit en ressources Kubernetes.

kompose est un outil pratique qui permet de passer du développement local de Docker à la gestion de votre application avec Kubernetes. La transformation du format Docker Compose en manifeste de ressources Kubernetes n'est peut-être pas exacte, mais elle aide énormément lors du premier déploiement d'une application sur Kubernetes.

Courir docker-compose.yaml ou votre propre fichier, lancez:

kompose up

Convertir docker-compose.yaml dans les déploiements et services Kubernetes avec une simple commande:

$ kompose convert -f docker-compose.yaml
INFO Kubernetes file "frontend-service.yaml" created         
INFO Kubernetes file "redis-master-service.yaml" created     
INFO Kubernetes file "redis-slave-service.yaml" created      
INFO Kubernetes file "frontend-deployment.yaml" created      
INFO Kubernetes file "redis-master-deployment.yaml" created  
INFO Kubernetes file "redis-slave-deployment.yaml" created

Pour plus d'informations, consultez: http://kompose.io/

16
JoaoCC

Kubernetes a certainement son propre yaml (comme indiqué dans " Déploiement d'applications ")

Mais comme " Comparaison des outils Docker: Kubernetes vs Docker Swarm ", cela n’a pas été écrit (uniquement) pour Docker, et il a son propre système.

Vous pouvez utiliser docker-compose pour démarrer Kubernetes, comme indiqué dans " vyshane/kid ": cela masque une partie des kubectl commandes dans les scripts (qui peut être versionné).

7
VonC