Kubernetes - Configurazione

È importante configurare il Virtual Datacenter (vDC) prima di configurare Kubernetes. Questo può essere considerato come un insieme di macchine in cui possono comunicare tra loro tramite la rete. Per un approccio pratico, è possibile configurare vDC suPROFITBRICKS se non si dispone di un'infrastruttura fisica o cloud configurata.

Una volta completata la configurazione IaaS su qualsiasi cloud, è necessario configurare il file Master e il Node.

Note- Viene mostrata la configurazione per le macchine Ubuntu. Lo stesso può essere impostato anche su altre macchine Linux.

Prerequisiti

Installing Docker- Docker è richiesto su tutte le istanze di Kubernetes. Di seguito sono riportati i passaggi per installare Docker.

Step 1 - Accedi alla macchina con l'account utente root.

Step 2- Aggiorna le informazioni sul pacchetto. Assicurati che il pacchetto apt funzioni.

Step 3 - Esegui i seguenti comandi.

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

Step 4 - Aggiungi la nuova chiave 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 - Aggiorna l'immagine del pacchetto API.

$ sudo apt-get update

Una volta completate tutte le attività di cui sopra, è possibile iniziare con l'installazione effettiva del motore Docker. Tuttavia, prima di questo è necessario verificare che la versione del kernel che si sta utilizzando sia corretta.

Installa Docker Engine

Eseguire i seguenti comandi per installare il motore Docker.

Step 1 - Accesso alla macchina.

Step 2 - Aggiorna l'indice del pacchetto.

$ sudo apt-get update

Step 3 - Installa il Docker Engine utilizzando il seguente comando.

$ sudo apt-get install docker-engine

Step 4 - Avvia il demone Docker.

$ sudo apt-get install docker-engine

Step 5 - Per molto se il Docker è installato, utilizzare il seguente comando.

$ sudo docker run hello-world

Installa etcd 2.0

Deve essere installato su Kubernetes Master Machine. Per installarlo, eseguire i seguenti comandi.

$ 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

Nella serie di comandi sopra -

• Innanzitutto, scarichiamo il file etcd. Salva questo con il nome specificato.
• Quindi, dobbiamo annullare il tar del pacchetto tar.
• Facciamo una dir. all'interno di / opt denominato bin.
• Copia il file estratto nella posizione di destinazione.

Ora siamo pronti per creare Kubernetes. Dobbiamo installare Kubernetes su tutte le macchine del cluster.

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

Il comando precedente creerà un file _outputdir nella radice della cartella kubernetes. Successivamente, possiamo estrarre la directory in una qualsiasi delle directory di nostra scelta / opt / bin, ecc.

Successivamente, viene la parte di rete in cui dobbiamo iniziare effettivamente con la configurazione del master e del nodo Kubernetes. Per fare ciò, creeremo una voce nel file host che può essere eseguita sulla macchina del nodo.

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

Di seguito sarà l'output del comando precedente.

Ora inizieremo con la configurazione effettiva su Kubernetes Master.

Innanzitutto, inizieremo a copiare tutti i file di configurazione nella loro posizione corretta.

$ 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/

Il comando precedente copierà tutti i file di configurazione nella posizione richiesta. Ora torneremo alla stessa directory in cui abbiamo creato la cartella 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/

Il passo successivo è aggiornare il file di configurazione copiato in / etc. dir.

Configurare etcd sul master utilizzando il seguente comando.

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

Configura kube-apiserver

Per questo sul master, dobbiamo modificare il file /etc/default/kube-apiserver file che abbiamo copiato in precedenza.

$ 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"

Configurare kube Controller Manager

Dobbiamo aggiungere il seguente contenuto in /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

Successivamente, configura lo scheduler kube nel file corrispondente.

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

Una volta che tutte le attività di cui sopra sono state completate, possiamo procedere aprendo il Kubernetes Master. Per fare ciò, riavvieremo il Docker.

$ service docker restart

Configurazione del nodo Kubernetes

Il nodo Kubernetes eseguirà due servizi, il kubelet and the kube-proxy. Prima di andare avanti, dobbiamo copiare i file binari che abbiamo scaricato nelle cartelle richieste in cui vogliamo configurare il nodo kubernetes.

Usa lo stesso metodo per copiare i file che abbiamo fatto per kubernetes master. Dato che eseguirà solo kubelet e kube-proxy, li configureremo.

$ 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/

Ora copieremo il contenuto nella directory appropriata.

$ 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/

Configureremo il kubelet e kube-proxy conf File.

Configureremo il /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"
/

Per kube-proxy, configureremo utilizzando il seguente comando.

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

Infine, riavvieremo il servizio Docker.

$ service docker restart

Ora abbiamo finito con la configurazione. Puoi controllare eseguendo i seguenti comandi.

$ /opt/bin/kubectl get minions