Configuration de Kubernetes sur site –

Dans cette série en plusieurs parties, je vais vous expliquer comment j'ai mis en place un pipeline d'apprentissage machine sur site avec des outils et des frameworks open-source.

Prologue: La formation des modèles n'est qu'un A Tiny Partie

Lorsque la plupart des gens pensent à l'apprentissage automatique, ils imaginent des ingénieurs et des scientifiques des données peaufiner les architectures de réseau, les fonctions de perte et régler les hyper-paramètres, couplés à un recyclage constant jusqu'à ce que les résultats soient satisfaisants.

En effet, la formation les modèles d'apprentissage automatique nécessitent beaucoup de travail. Un temps et des ressources énormes sont consacrés à la recherche et à l'expérimentation.

Cependant, il arrive un moment où vous devez commencer à produire le modèle que vous avez amoureusement formé et réglé. Et oh, au fait, le modèle devrait également fonctionner sur le lot de données des prochaines semaines.

Il vous apparaît lentement que le Machine Learning est beaucoup plus important que les modèles, les hyper-paramètres et les fonctions de perte. C'est aussi ce qui se passe avant, pendant et après l'entraînement. Et cela ne s'arrête pas là, car vous devez également penser à la formation concernant en particulier lorsque vous obtenez de nouvelles données, car il n'y a aucune garantie que le modèle se généralisera également.

Il existe un diagramme très bien connu qui illustre succinctement le problème:

En bref, vous devez créer un pipeline d'apprentissage automatique qui peut vous amener des données brutes aux personnes formées modèle dans les plus brefs délais. Mais voici le hic: parce que vous faites partie d'une startup scrappy et que vous ne débordez pas d'argent de VC, vous allez devoir vous contenter des serveurs que vous avez et ne pas compter sur les offres de cloud payantes d'Amazon, Microsoft ou Google , du moins pour le moment.

C'est parce que vous avez besoin d'un environnement sûr pour apprendre et expérimenter – un environnement qui ne vous choquera pas de façon inattendue avec une mauvaise facture à la fin du mois.

Qui vous êtes

Vous pourriez être ingénieur logiciel dans une entreprise qui commence à penser à mettre ses modèles d'apprentissage automatique en production, ou vous pourriez exécuter en solo et curieux de savoir à quoi ressemble l'apprentissage automatique "dans le monde réel". Dans les deux cas, vous devez connaître les pipelines d'apprentissage automatique.

Ce que vous devez savoir

Vous devez être à l'aise avec Linux. Les exemples supposeront Ubuntu Linux 18.04, bien que les versions légèrement datées ou plus récentes ne devraient pas causer de problèmes majeurs.

Vous devriez avoir une connaissance pratique de Docker. Si vous savez comment créer des images dans Docker et comment exécuter des conteneurs, vous devriez être prêt à partir. Si vous ne le faites pas, vous ne devriez pas trop vous inquiéter: je vais vous guider avec suffisamment d'informations de base et des exemples de code seront expliqués.

Bien qu'il s'agisse d'un article sur les pipelines de Machine Learning, cet article ne porte pas sur le subtilités impliquées dans la formation d'un modèle.

Nous allons utiliser Kubernetes. Vous n'avez pas besoin d'être un expert en la matière. Si vous êtes complètement nouveau sur Kubernetes, c'est OK. À la fin de la série, vous aurez au moins une expérience pratique. D'un autre côté, je ne vais pas approfondir les spécificités de Kubernetes. Je vais devoir passer sous silence certaines commandes dans un souci de concision. En outre, le véritable objectif ici est de vous aider à déployer les pipelines de Machine Learning aussi efficacement que possible.

Voici quelques autres hypothèses que je fais à votre sujet, le lecteur avisé:

1. vous n'êtes pas complètement ignorant du Machine Learning
2. vous avez accès à des serveurs relativement puissants (idéalement plus d'un) qui contiennent des GPU Nvidia
3. vous avez une base de code d'apprentissage automatique existante qui est écrite en Python
4. vous ne travaillez pas dans une startup licorne ou Fortune 500 et ne sont donc pas si riches en liquidités que vous pouvez faire tourner plusieurs V100 avec plaisir.

Que allons-nous faire?

Les pipelines d'apprentissage automatique n'ont que récemment reçu plus d'amour et d'attention, et les gens commencent à peine à comprendre tout. Autrement dit, il existe plusieurs façons de créer des pipelines d'apprentissage automatique, car chaque organisation a des exigences uniques et chaque équipe a son outil préféré.

Ce que cette série vise à offrir est une une façon possible de faites-le, et c'est particulièrement important lorsque vous débutez, car la quantité d'informations est souvent très accablante. En outre, l'installation de Kubernetes est une affaire intimidante, jonchée de nombreux barrages routiers. J'espère que cet article vous aidera à lisser ce chemin.

Après avoir appris une façon de créer un pipeline d'apprentissage automatique, vous serez alors équipé de suffisamment de compétences et de connaissances pour en construire un qui vous conviendra.

Voici une liste de certains des outils que je vais couvrir dans cette série:

• Docker
• Kubernetes
• Rancher
• KubeFlow / KubeFlow Pipelines
• Minio
• Tensorflow

On-premise

Comme vous vous en rendrez compte dès que vous suivrez la série, beaucoup de ces outils supposent que vous avez du stockage sur Amazon S3 ou Google Cloud Storage, ce qui, pour le dire doucement, n'est pas très bonne hypothèse. Ainsi, cette série montre comment contourner certaines de ces limitations sans perdre aucune des fonctionnalités.

Bien sûr, à un moment donné, vous deviendrez trop grand et aurez besoin de quelque chose de plus capable. Cependant, surtout lorsque vous commencez (c'est-à-dire que vous êtes le premier ingénieur de données de l'équipe), alors sur site semblerait plus rentable et finalement plus plus éducatif. choix.

Installation de Kubernetes en toute simplicité avec Rancher

Commençons immédiatement par l'un des éléments les plus difficiles – Installation de Kubernetes.

La principale chose que vous devez savoir sur Kubernetes est qu'il s'agit d'une orchestration de conteneurs système pour automatiser le déploiement, la mise à l'échelle et la gestion des applications.

Il existe de nombreuses façons d'installer Kubernetes, et ce n'est pas un processus trivial. Heureusement, des outils comme Rancher rendent le processus d'installation beaucoup plus agréable et moins sujet aux erreurs. En particulier, nous allons utiliser le moteur Rancher Kubernetes (RKE) pour nous aider à installer Kubernetes.

Au moment d'écrire ces lignes, la dernière version stable de rke est 1.0. 0 .

Étape 0: préparation des machines

Les étapes suivantes supposent que vous avez accès à deux machines Linux connectées au même réseau local.

Nous allons configurer un cluster minimal composé de deux machines, l'une nommée maître et l'autre ouvrier . Bien sûr, vous pouvez nommer vos machines comme vous le souhaitez, tant que vous désignez une machine comme maître et les autres comme ouvrières.

Si vous n’avez accès qu’à une seule machine, vous pouvez vous en tirer en créant deux machines virtuelles. et assurez-vous d'activer l'adaptateur ponté. En fait, en préparation de cet article, je teste tout à partir d'Oracle VirtualBox. Voici mes paramètres:

Notez ici que j'ai deux machines virtuelles: master et node . Activez l'adaptateur ponté et définissez également Mode de promiscuité sur Autoriser tout .

L'inconvénient est que vous ne pourrez pas accéder aux GPU , et vous remarquerez très probablement que les performances ne seront pas idéales car Kubernetes a tendance à être assez exigeant en termes de ressources. Encore une fois, ce n'est pas grave si vous essayez cela à la maison ou si vous n'avez accès qu'à une seule machine pour le moment.

Voici quelques détails importants sur les machines (vous devriez également les avoir sous la main pour les étapes de configuration qui suivent) :

DNS et équilibrage de charge

Dans un environnement de production, vous auriez besoin d'un nom d'hôte pour pointer vers votre cluster Kubernetes. Cependant, dans cet article, je suppose que vous n'en avez pas facilement disponible, donc nous allons devoir le simuler.

Une autre chose que je ne couvrirai pas – pour garder les choses simples – est l'équilibrage de charge en ce qui concerne l'installation de Rancher.

Pour nos besoins, je vais utiliser rancher-demo.domain.test comme nom d'hôte.

Dans les deux machines, ouvrez / etc / hosts fichier:

 sudo vim / etc / hosts

Saisissez les informations suivantes:

 192.168.86.35 ouvrier
192.168.86.35 rancher-demo.domain.test
192.168.86.36 maître
127.0.0.1 localhost

Notez ici que le nœud de travail a le nom d'hôte supplémentaire de rancher-demo.domain.test . Dans un environnement légèrement plus réaliste, vous auriez quelque chose comme NGINX comme frontal pour charger l'équilibre entre plusieurs nœuds de travail.

* Remarque: Si vous utilisez une machine virtuelle, alors vous utiliserez probablement l'image du serveur Ubuntu, qui n'est généralement pas fournie avec un environnement de bureau. Par conséquent, vous devez également avoir une entrée dans l'ordinateur hôte pour l'inclure:

 192.168.86.35 rancher-demo.domain.test

De cette façon, vous pourrez accéder à Rancher à partir d'un navigateur sur l'ordinateur hôte. *

Étape 1: Obtenez le rke Binaire

Important !: Cette étape ne doit être exécuté que sur master .

Rendez-vous sur la page GitHub pour télécharger le binaire rke . Ensuite, renommez le binaire en rke puis rendez-le exécutable. Enfin, déplacez le binaire vers un emplacement dans le CHEMIN où / usr / local / bin est généralement un bon choix.

Important: assurez-vous de sélectionner le bon binaire pour votre système d'exploitation!

 $ wget https://github.com/rancher/rke/releases/download/v1.0.0/rke_linux-amd64
$ mv rke_linux-amd64 rke
$ chmod + x rke
$ sudo mv rke / usr / local / bin

Voyons maintenant si tout fonctionne:

 $ rke

Cela devrait revenir:

 NOM:
   rke - Rancher Kubernetes Engine, un installateur Kubernetes extrêmement simple et ultra rapide qui fonctionne partout

USAGE:
   rke [global options] commande [command options] [arguments...]

 VERSION:
   v1.0.0

AUTEURS):
   Rancher Labs, Inc.

COMMANDES:
     up Amenez le cluster
     supprimer le démontage du cluster et nettoyer les nœuds du cluster
     version Afficher la version du cluster Kubernetes
     config Configuration de la configuration du cluster
     etcd etcd snapshot opérations de sauvegarde / restauration dans le cluster k8s
     cert Gestion des certificats pour le cluster RKE
     chiffrer Gérer les clés de fournisseur de chiffrement de cluster
     help, h Affiche une liste de commandes ou aide pour une commande

OPTIONS MONDIALES:
   --debug, -d Journalisation du débogage
   --quiet, -q Mode silencieux, désactive la journalisation et seule la sortie critique sera imprimée
   --help, -h afficher l'aide
   --version, -v imprimer la version

Étape 2. Préparation des hôtes Linux

Important: ces étapes doivent être effectuées sur toutes des machines.

a) Installer Docker

Tout d'abord, assurez-vous que Docker 19.03 est installé sur tous les hôtes Linux:

 $ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $ (lsb_release -cs) bord stable"
$ sudo apt-get update
$ sudo apt-get install -y docker-ce

Pour vous assurer que le service Docker fonctionne correctement, exécutez ce qui suit:

 $ sudo systemctl status docker

Cela devrait renvoyer:

 ● docker.service - Moteur de conteneur d'application Docker
   Chargé: chargé (/lib/systemd/system/docker.service; activé; préréglage du fournisseur: activé)
   Actif: actif (en cours d'exécution) depuis le samedi 2019-12-28 03:01:03 UTC; Il y a 27 ans
     Documents: https://docs.docker.com
 PID principal: 4118 (dockerd)
    Tâches: 8
   CGroup: /system.slice/docker.service
           411─4118 / usr / bin / dockerd -H fd: // --containerd = / run / containerd / containerd.sock

28 décembre 03:01:03 master dockerd [4118]: time = "2019-12-28T03: 01: 03.179311453Z" level = warning msg = "Votre noyau ne prend pas en charge la limite de mémoire de swap"
28 décembre 03:01:03 master dockerd [4118]: time = "2019-12-28T03: 01: 03.179509363Z" level = warning msg = "Votre noyau ne prend pas en charge la période rt cgroup"
28 décembre 03:01:03 master dockerd [4118]: time = "2019-12-28T03: 01: 03.179608175Z" level = warning msg = "Votre noyau ne prend pas en charge le runtime cgroup rt"

Exécutez maintenant la commande suivante pour pouvoir utiliser la commande docker sans sudo :

 $ sudo usermod -aG docker $ USER

Essayons:

 $ docker run hello-world

Oups!

 docker: obtention de l'autorisation refusée lors de la tentative de connexion au socket du démon Docker sous unix: ///var/run/docker.sock: publication http: //%2Fvar%2Frun%2Fdocker.sock/ v1.40 / containers / create: composer unix /var/run/docker.sock: connect: autorisation refusée.
Voir 'docker run --help'.

La raison pour laquelle vous obtenez ceci est que vous devez d'abord vous déconnecter :

 $ exit

Une fois connecté, réessayez:

 $ docker run hello-world

Vous devriez voir ceci:

 Impossible de trouver l'image 'hello-world: latest' localement
dernier: Tirer de bibliothèque / hello-world
1b930d010525: traction complète
Résumé: sha256: 4fe721ccc2e8dc7362278a29dc660d833570ec2682f4e4194f4ee23e415e1064
Statut: Image plus récente téléchargée pour hello-world: dernière

Bonjour de Docker!
Ce message indique que votre installation semble fonctionner correctement.

b) Configurer les clés SSH

Si vous n'avez pas configuré de clés SSH, effectuez l'étape suivante sur master :

 $ ssh-keygen
$ eval "$ (ssh-agent -s)"
$ ssh-add ~ / .ssh / id_rsa

Ensuite, copiez la clé publique sur tous les nœuds de travail. Puisque nous n'avons qu'un seul nœud de travail:

 $ ssh-copy-id ubuntu@192.168.86.36

Vous devez vous assurer que $ USER peut SSH dans les nœuds. Par exemple, assurez-vous que vous pouvez accéder à worker à partir de master :

 ubuntu @ master: ~ $ ssh ubuntu@192.168.86.36

Sur les deux nœuds, configurez le serveur SSH pour autoriser la redirection de port:

% sudo vim / etc / ssh / sshd_config

Décommentez ce qui suit:

 AllowTcpForwarding oui

c) Désactiver le swap

Pour désactiver le swap:

 $ sudo swapoff -a

Ouvrez / etc / fstab dans votre éditeur préféré et commentez l'entrée du fichier d'échange:

 $ sudo vim / etc / fstab

d) Appliquer les paramètres sysctl

 $ sudo sysctl net.bridge.bridge-nf-call-iptables = 1

e) DNS sur Ubuntu 18.04

Dans cette version d'Ubuntu, la façon dont le DNS est configuré a changé. Pour revenir au comportement précédent:

 $ sudo apt install resolvconf

Modifiez les paramètres du serveur de noms:

 sudo vim /etc/resolvconf/resolv.conf.d/head

Ajoutez les entrées suivantes:

 nameserver 8.8.4.4
serveur de noms 8.8.8.8

Redémarrez le service resolveconf :

% sudo service resolvconf restart

Étape 3: création du fichier de configuration du cluster

Important: l'étape suivante ne doit être effectuée que sur master .

Il est temps d'installer enfin Kubernetes avec ] rke !

Avant de procéder, assurez-vous que vous disposez d'une liste d'adresses IP et de noms d'hôte pour les nœuds. Le tableau de Étape 0 serait très utile pour cette étape.

Vous devrez exécuter rke config pour créer un fichier de configuration de cluster. Il vous présentera un tas de questions qui sont utilisées pour générer le fichier de configuration:

 $ rke config

Voici un exemple des questions et réponses basées sur le tableau. N'oubliez pas de l'adapter à vos utilisateurs, noms d'hôte, adresses IP et emplacements des clés SSH. Notez également que le nœud maître devrait avoir le rôle de avion de contrôle et etcd tandis que les nœuds ouvrier devraient avoir le rôle de travailleur . Si jamais vous vous trompez, vous pouvez toujours recommencer avec Ctrl + C et relancer la commande:

 [+] Cluster Level SSH Private Key Path [~/.ssh/id_rsa]:
[+] Nombre d'hôtes [1]: 2
[+] Adresse SSH de l'hôte (1) [none]: 192.168.86.36
[+] Port hôte SSH (1) [22]:
[+] Chemin d'accès de la clé privée SSH de l'hôte (192.168.86.36) [none]: ~ / .ssh / id_rsa
[+] Utilisateur SSH de l'hôte (192.168.86.36) [ubuntu]: ubuntu
[+] L'hôte (192.168.86.36) est-il un hôte du plan de contrôle (o / n)? [y]: y
[+] L'hôte (192.168.86.36) est-il un hôte travailleur (o / n)? [n]: n
[+] L'hôte (192.168.86.36) est-il un hôte etcd (o / n)? [n]: y
[+] Remplacer le nom d'hôte de l'hôte (192.168.86.36) [none]: maître
[+] IP interne de l'hôte (192.168.86.36) [none]:
[+] Chemin du socket Docker sur l'hôte (192.168.86.36) [/var/run/docker.sock]:
[+] Adresse SSH de l'hôte (2) [none]: 192.168.86.35
[+] Port hôte SSH (2) [22]:
[+] Chemin d'accès de la clé privée SSH de l'hôte (192.168.86.35) [none]: ~ / .ssh / id_rsa
[+] Utilisateur SSH de l'hôte (192.168.86.35) [ubuntu]: ubuntu
[+] L'hôte (192.168.86.35) est-il un hôte du plan de contrôle (o / n)? [y]: n
[+] L'hôte (192.168.86.35) est-il un hôte travailleur (o / n)? [n]: y
[+] L'hôte (192.168.86.35) est-il un hôte etcd (o / n)? [n]: n
[+] Remplacer le nom d'hôte de l'hôte (192.168.86.35) [none]: travailleur
[+] IP interne de l'hôte (192.168.86.35) [none]:
[+] Chemin du socket Docker sur l'hôte (192.168.86.35) [/var/run/docker.sock]:
[+] Type de plugin réseau (flanelle, calicot, tissage, canal) [canal]: flanelle
[+] Stratégie d'authentification [x509]:
[+] Mode d'autorisation (rbac, aucun) [rbac]:
[+] Image Docker de Kubernetes [rancher/hyperkube:v1.16.3-rancher1]:
[+] Domaine de cluster [cluster.local]:
[+] Plage d'adresses IP du cluster de services [10.43.0.0/16]:
[+] Activer PodSecurityPolicy [n]:
[+] Réseau de clusters CIDR [10.42.0.0/16]:
[+] Cluster DNS Service IP [10.43.0.10]:
[+] Ajouter des URL de manifeste d'addon ou des fichiers YAML [no]:

Cela génère cluster.yml le fichier de configuration du cluster RKE:

 nœuds:
- adresse: "192.168.86.36"
  port: "22"
  adresse_interne: ""
  rôle:
  - avion de contrôle
  - etcd
  hostname_override: ""
  utilisateur: ubuntu
  docker_socket: /var/run/docker.sock
  ssh_key: ""
  ssh_key_path: ~ / .ssh / id_rsa
  ssh_cert: ""
  ssh_cert_path: ""
  Étiquettes: {}
  souillures: []
- adresse: "192.168.86.35"
  port: "22"
  adresse_interne: ""
  rôle:
  - ouvrier
  hostname_override: ""
  utilisateur: ubuntu
  docker_socket: /var/run/docker.sock
  ssh_key: ""
  ssh_key_path: ~ / .ssh / id_rsa
  ssh_cert: ""
  ssh_cert_path: ""
  Étiquettes: {}
  souillures: []
prestations de service:
  etcd:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
    external_urls: []
    ca_cert: ""
    cert: ""
    clé: ""
    chemin: ""
    uid: 0
    gid: 0
    instantané: null
    rétention: ""
    création: ""
    backup_config: null
  kube-api:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
    service_cluster_ip_range: 10.43.0.0/16
    service_node_port_range: ""
    pod_security_policy: false
    always_pull_images: false
    secrets_encryption_config: null
    audit_log: null
    admission_configuration: null
    event_rate_limit: null
  kube-controller:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
    cluster_cidr: 10.42.0.0/16
    service_cluster_ip_range: 10.43.0.0/16
  planificateur:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
  kubelet:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
    cluster_domain: cluster.local
    infra_container_image: ""
    cluster_dns_server: 10.43.0.10
    fail_swap_on: false
    generate_serving_certificate: false
  kubeproxy:
    image: ""
    extra_args: {}
    extra_binds: []
    extra_env: []
réseau:
  plugin: flanelle
  options: {}
  node_selector: {}
authentification:
  stratégie: x509
  sans: []
  webhook: null
modules complémentaires: ""
addons_include: []
images_système:
  etcd: rancher / coreos-etcd: v3.3.15-rancher1
  alpin: rancher / rke-tools: v0.1.51
  nginx_proxy: rancher / rke-tools: v0.1.51
  cert_downloader: rancher / rke-tools: v0.1.51
  kubernetes_services_sidecar: rancher / rke-tools: v0.1.51
  kubedns: rancher / k8s-dns-kube-dns: 1.15.0
  dnsmasq: éleveur / k8s-dns-dnsmasq-nanny: 1.15.0
  kubedns_sidecar: rancher / k8s-dns-sidecar: 1.15.0
  kubedns_autoscaler: rancher / cluster-proportionnel-autoscaler: 1.7.1
  coredns: rancher / coredns-coredns: 1.6.2
  coredns_autoscaler: rancher / cluster-proportionnel-autoscaler: 1.7.1
  kubernetes: rancher / hyperkube: v1.16.3-rancher1
  flanelle: rancher / coreos-flannel: v0.11.0-rancher1
  flannel_cni: rancher / flannel-cni: v0.3.0-rancher5
  calico_node: rancher / calico-node: v3.8.1
  calico_cni: rancher / calico-cni: v3.8.1
  calico_controllers: rancher / contrôleurs calico-kube: v3.8.1
  calico_ctl: ""
  calico_flexvol: rancher / calico-pod2daemon-flexvol: v3.8.1
  canal_node: rancher / calico-node: v3.8.1
  canal_cni: rancher / calico-cni: v3.8.1
  canal_flannel: rancher / coreos-flannel: v0.11.0
  canal_flexvol: rancher / calico-pod2daemon-flexvol: v3.8.1
  weave_node: weaveworks / weave-kube: 2.5.2
  weave_cni: weaveworks / weave-npc: 2.5.2
  pod_infra_container: éleveur / pause: 3.1
  entrée: rancher / nginx-ingress-controller: nginx-0.25.1-rancher1
  ingress_backend: rancher / nginx-ingress-controller-defaultbackend: 1.5-rancher1
  metrics_server: rancher / metrics-server: v0.3.4
  windows_pod_infra_container: rancher / kubelet-pause: v0.1.3
ssh_key_path: ~ / .ssh / id_rsa
ssh_cert_path: ""
ssh_agent_auth: false
autorisation:
  mode: rbac
  options: {}
ignore_docker_version: false
kubernetes_version: ""
registres_privée: []
entrée:
  fournisseur: ""
  options: {}
  node_selector: {}
  extra_args: {}
  dns_policy: ""
  extra_envs: []
  extra_volumes: []
  extra_volume_mounts: []
cluster_name: ""
cloud_provider:
  Nom: ""
prefix_path: ""
addon_job_timeout: 0
bastion_host:
  adresse: ""
  Port: ""
  utilisateur: ""
  ssh_key: ""
  ssh_key_path: ""
  ssh_cert: ""
  ssh_cert_path: ""
surveillance:
  fournisseur: ""
  options: {}
  node_selector: {}
restaurer:
  restaurer: faux
  nom_instantané: ""
dns: null

Il est temps de remonter le cluster!

% rke up

Attendez que rke configure le cluster Kubernetes:

 INFO [0000] Exécution de la version RKE: v1.0.0
INFO [0000] Lancement du cluster Kubernetes
INFO [0000] [certificates]  Génération de certificats d'administrateur et de kubeconfig
INFO [0000] Fichier d'état déployé avec succès à [./cluster.rkestate]
INFO [0000] Construction d'un cluster Kubernetes
INFO [0000] [dialer]  Configuration d'un tunnel pour l'hôte [192.168.86.35]
INFO [0000] [dialer]  Configuration d'un tunnel pour l'hôte [192.168.86.36]
# Beaucoup plus de lignes ...
INFO [0044] Construction du cluster Kubernetes terminée avec succès

Quelques fichiers supplémentaires auraient été créés à ce stade:

 $ ls
cluster.rkestate cluster.yml kube_config_cluster.yml

Vous devez conserver ces fichiers dans un endroit sûr si jamais vous avez besoin de recréer le cluster. Vous devez copier kube_config_cluster.yml vers un emplacement où Kubernetes peut le trouver:

 $ mkdir ~ / .kube
$ cp kube_config_cluster.yml $ HOME / .kube / config

Installer Kubectl

Remarque: cette étape ne doit être effectuée que sur le nœud maître .

Ensuite, vous devez installer l'outil de ligne de commande Kubernetes, kubectl :

 curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
mise à jour sudo apt-get
sudo apt-get install -y kubectl

Une fois cette étape terminée, nous pouvons la tester en répertoriant tous les nœuds créés par rke :

% kubectl get nodes
NOM STATUT ROLES AGE VERSION
192.168.86.35 Travailleur prêt 53m v1.16.3
192.168.86.36 Controlplane Ready, etcd 53m v1.16.3

Succès! Faisons quelque chose d'autre. Nous pouvons inspecter quels conteneurs ont été créés:

% kubectl get pods --all-namespaces
NAMESPACE NAME READY STATUS RESTARTS AGE
ingress-nginx default-http-backend-67cf578fc4-dk9l4 1/1 Running 0 49m
ingress-nginx nginx-ingress-controller-bnwlv 1/1 Course 0 49m
kube-system coredns-5c59fd465f-7gbff 1/1 Course 0 49m
kube-system coredns-5c59fd465f-mhzdb 1/1 Course 0 49m
kube-system coredns-autoscaler-d765c8497-p2zj4 1/1 Course 0 49m
kube-system kube-flannel-vkxc6 2/2 Course 0 54m
kube-system kube-flannel-xjtst 2/2 Course 0 54m
kube-system metrics-server-64f6dffb84-hs99g 1/1 Running 0 49m
kube-system rke-coredns-addon-deploy-job-kdwxm 0/1 Terminé 0 49m
kube-system rke-ingress-controller-deploy-job-rpvrq 0/1 Terminé 0 49m
kube-system rke-metrics-addon-deploy-job-x2m2j 0/1 Terminé 0 49m
kube-system rke-network-plugin-deploy-job-h5ffz 0/1 Terminé 0 55m

Ne vous inquiétez pas de ce que sont les modules à ce stade. Considérez-les comme des conteneurs pour le moment.

Installez Helm 3

Remarque: cette étape ne doit être effectuée que sur le nœud master .

Helm est un Kubernetes gestionnaire de packages et est très pratique pour déployer des applications et des services sur des clusters Kubernetes. Nous utiliserons Helm pour installer Rancher et d'autres services de support.

 $ curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | frapper

helm devrait être installé dans le CHEMIN :

 Téléchargement https://get.helm.sh/helm-v3.0.2-linux-amd64.tar.gz
Préparation de l'installation de Helm dans / usr / local / bin
barre installée dans / usr / local / bin / helm

Installer Rancher à l'aide de Helm

Remarque: Cette étape ne doit être effectuée que sur le nœud maître .

 $ helm repo add rancher-stable https: // releases .rancher.com / tableaux-serveurs / stable

Créer un espace de noms pour Rancher:

 $ kubectl créer un système de bovins d'espace de noms

Installer cert-manager

Remarque: cette étape ne doit être effectuée que sur le nœud master .

Cert Manager aide à l'approvisionnement automatique et la gestion des certificats TLS dans Kubernetes. Il existe des options pour utiliser des certificats de Let's Encrypt par exemple, mais pour l'instant, nous allons garder les choses simples et utiliser les certificats par défaut générés par Rancher.

Remarque: ici, nous installons une version légèrement obsolète de cert-manager car le dernier (0.12) semble avoir des problèmes d'installation.

Suivez ces étapes pour installer cert-manager sur le cluster Kubernetes:

 $ kubectl appliquer -f https://raw.githubusercontent.com/jetstack/cert-manager/release-0.9/deploy/manifests/00-crds.yaml
$ kubectl créer un gestionnaire de certificats d'espace de noms
$ kubectl label namespace cert-manager certmanager.k8s.io/disable-validation=true
$ helm repo add jetstack https://charts.jetstack.io
$ helm repo update
$ helm install --name cert-manager 
          --namespace cert-manager 
          --version v0.9.1 
          jetstack / cert-manager

Vérifiez que tout s'est bien passé:

 kubectl get pods --namespace cert-manager
NOM READY STATUS RESTARTS AGE
cert-manager-5b9ff77b7-x6vgn 1/1 Fonctionnement 0 44s
cert-manager-cainjector-59d69b9b-nrgkf 1/1 Running 0 44s
cert-manager-webhook-cfd6587ff-8tcgt 1/1 Running 0 44s

Notez que vous devrez peut-être attendre un certain temps (généralement quelques minutes) pour que tous les STATUS se tournent vers Running .

Install Rancher

Enfin , vous pouvez installer Rancher, qui, entre autres, fournit une interface agréable pour gérer vos clusters Kubernetes:

 $ helm install rancher rancher-stable / rancher 
  - système bovin de l'espace de noms 
  --set hostname = rancher.example.com

Vérifier que tout s'est bien passé:

 kubectl -n statut de déploiement du système bovin déploiement / élevage

 En attente du déploiement du déploiement "rancher": 0 répliques mises à jour sur 3 sont disponibles ...

Attendez que toutes les répliques aient été mises à jour avant d'effectuer l'étape suivante.

Maintenant, comme nous n'avons pas d'équilibreur de charge, nous devons effectuer une étape supplémentaire pour pouvoir accéder à l'interface utilisateur Rancher. Créez le fichier suivant en le nommant ingress.yml et remplissez-le avec ce qui suit (adaptez l'hôte à ce que vous avez choisi):

 apiVersion: extensions / v1beta1
genre: Ingress
métadonnées:
  nom: rancher-demo-ingress
spec:
  règles:
  - hôte: rancher-demo.domain.test
    http:
      chemins:
      - chemin: /
        backend:
          serviceName: rancher-demo
          servicePort: 443

Exécutez ensuite:

 $ kubectl apply -f ingress.yml

Après cela, Rancher devrait être disponible sur:

 https: //rancher-demo.domain.test

Acceptez l'exception de sécurité dont votre navigateur pourrait se plaindre et vous devriez être accueilli avec l'écran suivant avec une invite pour créer un mot de passe et définir le nom de domaine (déjà pré-rempli). Allez-y et faites cela:

Donnez à Rancher quelques instants pour configurer les choses. Une fois cela fait, vous devriez avoir un aperçu de votre cluster:

Allez-y et cliquez et savourez les fruits de votre travail!

Résumé

Si vous avez atteint ce stade, vous devez vous féliciter d'avoir persévéré. L'installation d'un cluster Kubernetes n'est pas pour les âmes sensibles, même avec des outils comme Rancher pour faciliter quelque peu le processus.

Passons en revue ce que nous avons fait.

Nous avons expliqué pourquoi la formation Les modèles ML ne sont que la pointe de l'iceberg proverbial, et que de nombreux autres logiciels de soutien doivent être réunis pour être intégrés

Plus important encore, nous avons mis en place un cluster Kubernetes non trivial avec Rancher Kubernetes Engine et installé Rancher pour gérer le cluster. Ce n'est pas un exploit. Cependant, nous n'avons encore effectué aucun déploiement de machine learning! That will be the next article in the series, where we install Kubeflow, an open-source machine learning platform.

Credits

Special thanks go to this Sebastiaan van Steenis article that showed how to set up an RKE cluster without a load balancer.