Kubernetes - Configuration

Il est important de configurer le centre de données virtuel (vDC) avant de configurer Kubernetes. Cela peut être considéré comme un ensemble de machines sur lesquelles ils peuvent communiquer entre eux via le réseau. Pour une approche pratique, vous pouvez configurer vDC surPROFITBRICKS si vous ne disposez pas d'une infrastructure physique ou cloud configurée.

Une fois la configuration IaaS sur n'importe quel cloud terminée, vous devez configurer le Master et le Node.

Note- La configuration est affichée pour les machines Ubuntu. La même chose peut également être configurée sur d'autres machines Linux.

Conditions préalables

Installing Docker- Docker est requis sur toutes les instances de Kubernetes. Voici les étapes pour installer le Docker.

Step 1 - Connectez-vous à la machine avec le compte utilisateur root.

Step 2- Mettez à jour les informations sur le package. Assurez-vous que le paquet apt fonctionne.

Step 3 - Exécutez les commandes suivantes.

$ sudo apt-get update
$ sudo apt-get install apt-transport-https ca-certificates

Step 4 - Ajoutez la nouvelle clé GPG.

$ sudo apt-key adv \
   --keyserver hkp://ha.pool.sks-keyservers.net:80 \
   --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
$ echo "deb https://apt.dockerproject.org/repo ubuntu-trusty main" | sudo tee
/etc/apt/sources.list.d/docker.list

Step 5 - Mettez à jour l'image du package d'API.

$ sudo apt-get update

Une fois que toutes les tâches ci-dessus sont terminées, vous pouvez commencer par l'installation réelle du moteur Docker. Cependant, avant cela, vous devez vérifier que la version du noyau que vous utilisez est correcte.

Installer Docker Engine

Exécutez les commandes suivantes pour installer le moteur Docker.

Step 1 - Connectez-vous à la machine.

Step 2 - Mettez à jour l'index du package.

$ sudo apt-get update

Step 3 - Installez Docker Engine à l'aide de la commande suivante.

$ sudo apt-get install docker-engine

Step 4 - Démarrez le démon Docker.

$ sudo apt-get install docker-engine

Step 5 - Pour savoir si le Docker est installé, utilisez la commande suivante.

$ sudo docker run hello-world

Installez etcd 2.0

Cela doit être installé sur Kubernetes Master Machine. Pour l'installer, exécutez les commandes suivantes.

$ curl -L https://github.com/coreos/etcd/releases/download/v2.0.0/etcd
-v2.0.0-linux-amd64.tar.gz -o etcd-v2.0.0-linux-amd64.tar.gz ->1
$ tar xzvf etcd-v2.0.0-linux-amd64.tar.gz ------>2
$ cd etcd-v2.0.0-linux-amd64 ------------>3
$ mkdir /opt/bin ------------->4
$ cp etcd* /opt/bin ----------->5

Dans l'ensemble de commande ci-dessus -

  • Tout d'abord, nous téléchargeons le etcd. Enregistrez-le avec le nom spécifié.
  • Ensuite, nous devons décompresser le paquet tar.
  • Nous faisons un dir. à l'intérieur du / opt nommé bin.
  • Copiez le fichier extrait vers l'emplacement cible.

Nous sommes maintenant prêts à créer Kubernetes. Nous devons installer Kubernetes sur toutes les machines du cluster.

$ git clone https://github.com/GoogleCloudPlatform/kubernetes.git
$ cd kubernetes
$ make release

La commande ci-dessus créera un _outputdir à la racine du dossier kubernetes. Ensuite, nous pouvons extraire le répertoire dans n'importe quel répertoire de notre choix / opt / bin, etc.

Ensuite, vient la partie mise en réseau dans laquelle nous devons commencer par la configuration du maître et du nœud Kubernetes. Pour ce faire, nous allons faire une entrée dans le fichier hôte qui peut être effectuée sur la machine du nœud.

$ echo "<IP address of master machine> kube-master
< IP address of Node Machine>" >> /etc/hosts

Voici la sortie de la commande ci-dessus.

Maintenant, nous allons commencer par la configuration réelle sur Kubernetes Master.

Tout d'abord, nous commencerons à copier tous les fichiers de configuration à leur emplacement correct.

$ cp <Current dir. location>/kube-apiserver /opt/bin/
$ cp <Current dir. location>/kube-controller-manager /opt/bin/
$ cp <Current dir. location>/kube-kube-scheduler /opt/bin/
$ cp <Current dir. location>/kubecfg /opt/bin/
$ cp <Current dir. location>/kubectl /opt/bin/
$ cp <Current dir. location>/kubernetes /opt/bin/

La commande ci-dessus copiera tous les fichiers de configuration à l'emplacement requis. Nous reviendrons maintenant au même répertoire où nous avons construit le dossier Kubernetes.

$ cp kubernetes/cluster/ubuntu/init_conf/kube-apiserver.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-controller-manager.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-kube-scheduler.conf /etc/init/

$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-apiserver /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-controller-manager /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-kube-scheduler /etc/init.d/

$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kube-proxy /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/

L'étape suivante consiste à mettre à jour le fichier de configuration copié sous / etc. dir.

Configurez etcd sur le maître à l'aide de la commande suivante.

$ ETCD_OPTS = "-listen-client-urls = http://kube-master:4001"

Configurer kube-apiserver

Pour cela sur le master, nous devons éditer le /etc/default/kube-apiserver fichier que nous avons copié précédemment.

$ KUBE_APISERVER_OPTS = "--address = 0.0.0.0 \
--port = 8080 \
--etcd_servers = <The path that is configured in ETCD_OPTS> \
--portal_net = 11.1.1.0/24 \
--allow_privileged = false \
--kubelet_port = < Port you want to configure> \
--v = 0"

Configurer le gestionnaire de contrôleur kube

Nous devons ajouter le contenu suivant dans /etc/default/kube-controller-manager.

$ KUBE_CONTROLLER_MANAGER_OPTS = "--address = 0.0.0.0 \
--master = 127.0.0.1:8080 \
--machines = kube-minion \ -----> #this is the kubernatics node
--v = 0

Ensuite, configurez le planificateur kube dans le fichier correspondant.

$ KUBE_SCHEDULER_OPTS = "--address = 0.0.0.0 \
--master = 127.0.0.1:8080 \
--v = 0"

Une fois que toutes les tâches ci-dessus sont terminées, nous sommes prêts à aller de l'avant en mettant en place le maître Kubernetes. Pour ce faire, nous redémarrerons le Docker.

$ service docker restart

Configuration du nœud Kubernetes

Le nœud Kubernetes exécutera deux services le kubelet and the kube-proxy. Avant d'aller de l'avant, nous devons copier les binaires que nous avons téléchargés dans leurs dossiers requis où nous voulons configurer le nœud kubernetes.

Utilisez la même méthode de copie des fichiers que pour le maître kubernetes. Comme il n'exécutera que le kubelet et le kube-proxy, nous les configurerons.

$ cp <Path of the extracted file>/kubelet /opt/bin/
$ cp <Path of the extracted file>/kube-proxy /opt/bin/
$ cp <Path of the extracted file>/kubecfg /opt/bin/
$ cp <Path of the extracted file>/kubectl /opt/bin/
$ cp <Path of the extracted file>/kubernetes /opt/bin/

Maintenant, nous allons copier le contenu dans le répertoire approprié.

$ cp kubernetes/cluster/ubuntu/init_conf/kubelet.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-proxy.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kubelet /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-proxy /etc/init.d/
$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kube-proxy /etc/default/

Nous allons configurer le kubelet et kube-proxy conf des dossiers.

Nous allons configurer le /etc/init/kubelet.conf.

$ KUBELET_OPTS = "--address = 0.0.0.0 \
--port = 10250 \
--hostname_override = kube-minion \
--etcd_servers = http://kube-master:4001 \
--enable_server = true
--v = 0"
/

Pour kube-proxy, nous allons configurer à l'aide de la commande suivante.

$ KUBE_PROXY_OPTS = "--etcd_servers = http://kube-master:4001 \
--v = 0"
/etc/init/kube-proxy.conf

Enfin, nous redémarrerons le service Docker.

$ service docker restart

Nous avons maintenant terminé la configuration. Vous pouvez vérifier en exécutant les commandes suivantes.

$ /opt/bin/kubectl get minions