Peut Kubernetes être utilisé comme Docker Composer?

J'ai été fouiller dans les Kubernetes documentation pendant des heures. Je comprends la conception de base, et la notion de services, contrôleurs, cosses, etc.

Ce que je ne comprends pas, cependant, est le processus dans lequel je peux configurer de manière déclarative du cluster. C'est une façon pour moi d'écrire un fichier de configuration (ou un ensemble de celle-ci) pour définir le maquillage, et de l'échelle des options de déploiement cloud. Je veux être en mesure de déclarer que les conteneurs que je veux dans les modules, comment ils communiquent, comment ils vont échelle, etc. sans exécuter une tonne de commandes cli.

Est-il docker-composer fonctionnalité pour Kubernetes?

Je veux ma demande à être défini dans git—être la version contrôlée sans compter sur le manuel de la cli interactions.

Est-ce possible de le faire de façon concise? Est-il une référence qui n'est plus clair que la documentation officielle?

InformationsquelleAutor Don Scott | 2016-06-15

8

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

Nous avons d'abord besoin d'installer le Composer sur Kubernetes contrôleur dans votre Kubernetes cluster. Ce contrôleur utilise la norme de Kubernetes points d'extension pour introduire le Stack à la Kubernetes API. Vérifiez l'intégralité de la documentation pour installer le panneau de composer contrôleur:

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

Écrivons une simple composent 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 allons ensuite utiliser le support client pour déployer ce à un Kubernetes cluster en cours d'exécution du 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
```
On peut alors interagir avec ces objets via le Kubernetes API. Ici vous pouvez le voir, nous avons créé les objets de niveau inférieur comme les Services, les Gousses, les Déploiements et ReplicaSets automatiquement:
```
$ 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 ce n'est pas un temps de conversion. Le Composer sur Kubernetes de l'API Serveur introduit la Pile de ressources à la Kubernetes API. Nous pouvons donc nous interroger et de gérer tout au même niveau d'abstraction que nous sommes la génération de l'application. Qui fait entrer dans les détails ci-dessus, utile pour comprendre comment les choses fonctionnent, ou le débogage de problèmes, mais pas nécessaire la plupart du temps:
```
$ kubectl get stack
NAME      STATUS      PUBLISHED PORTS   PODS     AGE      
words     Running     33000             5/5      4m
```
InformationsquelleAutor Prafull Ladha
33

Si vous êtes toujours à la recherche, peut-être que cet outil peut aider: https://github.com/kelseyhightower/compose2kube

Vous pouvez créer un fichier composer:
```
# sample compose file with 3 services
web:
  image: nginx
  ports:
    - "80"
    - "443"
database:
  image: postgres
  ports:
    - "5432"
cache:
  image: memcached
  ports:
    - "11211"
```
Alors utiliser l'outil pour convertir kubernetes objets:
```
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 de les appliquer à kubernetes.
- S'il vous plaît ne pas ajouter un lien seules réponses. Des liens peuvent disparaître.
- Salut Ahmad, et bienvenue à Débordement de Pile. Comme @KurtVandenBranden dit, le lien-seulement les réponses ne sont pas excellents en eux-mêmes; il est important d'inclure un certain contexte, par exemple en citant la partie importante de l'article lié, pour en faire une réponse utile, même au sein de ce site. Voir Comment Répondre pour plus de conseils.
InformationsquelleAutor Ahmad Aabed
16

Si vous avez déjà Docker Compositeur de fichiers, vous pouvez prendre un coup d'oeil à la Kompose projet.

kompose est un outil pour aider les utilisateurs qui sont familiers avec docker-composition de passer à Kubernetes. kompose prend un menu fixe Composer de fichiers et les traduit en Kubernetes ressources.

kompose est une commodité outil pour aller de locaux Docker développement à la gestion de votre application avec Kubernetes. La Transformation de l'Docker Composer format de Kubernetes ressources manifeste peut-être pas exact, mais il aide énormément lors de la première du déploiement d'une application sur Kubernetes.

Pour exécuter docker-compose.yaml fichier ou de votre propre, exécutez:
```
kompose up
```
Pour convertir docker-compose.yaml en Kubernetes et de déploiements de services 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/

InformationsquelleAutor JoaoCC
7

Kubernetes a certainement ses propres yaml (comme indiqué dans "Le Déploiement Des Applications")

Mais comme "Le panneau Outils de Clustering de Comparaison: Kubernetes vs Docker Essaim", il n'a pas été écrit (juste) pour Docker, et il a son propre système.

Vous pouvez utiliser docker-composer pour commencer Kubernetes bien que, comme indiqué dans "vyshane/enfant": qui ne masque certains kubectl commandes de la cli dans les scripts (qui peuvent être versionnés).
- pour un déploiement géré (c'est à dire Google est un Service de Conteneurs) je ne pense pas que docker-compose-kubernetes est applicable. (Il est également déconseillé de projet.) Je suppose que ce que je veux savoir est ce que une grande organisation pour gérer les déploiements. Est-il un kubernetes de gestion de paquet, je peux nourrir de configuration yaml pour?
- Bon point. J'ai mis à jour la réponse à la non-déconseillé de projet.
InformationsquelleAutor VonC

Vous devez vous connecter pour publier un commentaire.