Vizualizare sursă pentru „Implementarea unui cluster Kubernetes”

<span data-link_translate_fr_title="Deployer un cluster Kubernetes"  data-link_translate_fr_url="Deployer un cluster Kubernetes"></span>[[:fr:Deployer un cluster Kubernetes]][[fr:Deployer un cluster Kubernetes]]
<br />Acest articol este rezultatul unei traduceri automate efectuate de către software-ul. Puteți vizualiza sursa articol [[:fr:Array|aici]].<br /><span data-translate="fr"></span><br />
<span data-link_translate_ru_title="Развертывание кластера Kubernetes"  data-link_translate_ru_url="Развертывание кластера Kubernetes"></span>[[:ru:Развертывание кластера Kubernetes]][[ru:Развертывание кластера Kubernetes]]
<span data-link_translate_pl_title="Wdrażanie klastra Kubernetes"  data-link_translate_pl_url="Wdrażanie klastra Kubernetes"></span>[[:pl:Wdrażanie klastra Kubernetes]][[pl:Wdrażanie klastra Kubernetes]]
<span data-link_translate_ja_title="Kubernetesクラスタのデプロイ"  data-link_translate_ja_url="Kubernetesクラスタのデプロイ"></span>[[:ja:Kubernetesクラスタのデプロイ]][[ja:Kubernetesクラスタのデプロイ]]
<span data-link_translate_zh_title="部署一个Kubernetes集群"  data-link_translate_zh_url="部署一个Kubernetes集群"></span>[[:zh:部署一个Kubernetes集群]][[zh:部署一个Kubernetes集群]]
<span data-link_translate_de_title="Bereitstellen eines Kubernetes-Clusters"  data-link_translate_de_url="Bereitstellen eines Kubernetes-Clusters"></span>[[:de:Bereitstellen eines Kubernetes-Clusters]][[de:Bereitstellen eines Kubernetes-Clusters]]
<span data-link_translate_nl_title="Een Kubernetes cluster implementeren"  data-link_translate_nl_url="Een Kubernetes cluster implementeren"></span>[[:nl:Een Kubernetes cluster implementeren]][[nl:Een Kubernetes cluster implementeren]]
<span data-link_translate_pt_title="Implantação de um aglomerado Kubernetes"  data-link_translate_pt_url="Implantação de um aglomerado Kubernetes"></span>[[:pt:Implantação de um aglomerado Kubernetes]][[pt:Implantação de um aglomerado Kubernetes]]
<span data-link_translate_es_title="Despliegue de un clúster Kubernetes"  data-link_translate_es_url="Despliegue de un clúster Kubernetes"></span>[[:es:Despliegue de un clúster Kubernetes]][[es:Despliegue de un clúster Kubernetes]]
<span data-link_translate_en_title="Deploying a Kubernetes cluster"  data-link_translate_en_url="Deploying a Kubernetes cluster"></span>[[:en:Deploying a Kubernetes cluster]][[en:Deploying a Kubernetes cluster]]
<span data-link_translate_it_title="Configurare un cluster Kubernetes"  data-link_translate_it_url="Configurare un cluster Kubernetes"></span>[[:it:Configurare un cluster Kubernetes]][[it:Configurare un cluster Kubernetes]]
<span data-link_translate_fr_title="Deployer un cluster Kubernetes"  data-link_translate_fr_url="Deployer un cluster Kubernetes"></span>[[:fr:Deployer un cluster Kubernetes]][[fr:Deployer un cluster Kubernetes]]


{{#seo:
|title=Instalarea kubernetes
|titlemode=replace
|keywords=ikoula wiki, ikoula wiki, ikoula knowledge base, kubernetes este ce, kubernetes instalare, kubernetes tutorial
|description=Kubernetes poate fi considerat ca fiind: o platformă de containere, o platformă de microservicii, o platformă cloud portabilă și multe altele...Aflați cum se instalează.
|og:type=article
|og:image=https://fr-wiki.ikoula.com/resources/assets/logo_ikwiki.png
}} 

==Ce este Kubernetes?==

'''[https://www.ikoula.ro/ro/cloud-public/oneclick/kubernetes Kubernetes]''' este o platformă open-source pentru gestionarea sarcinilor de lucru și a serviciilor containerizate.
Acesta suportă scrierea declarativă a configurației, dar și automatizarea. ''Kubernetes'' este un ecosistem mare și în creștere rapidă.


Această procedură vă va permite să implementați rapid și ușor un cluster cu trei noduri. [https://www.ikoula.ro/ro/cloud-public/oneclick/kubernetes Kubernetes (k8s)] Această procedură vă va permite să implementați rapid și ușor un cluster cu trei noduri din trei instanțe CentOS 7 implementate în aceeași rețea într-o zonă de înaintare.


Una dintre aceste trei instanțe va fi nodul nostru principal, iar celelalte două vor fi nodurile noastre de lucru. Pe scurt, nodul maestru este nodul de la care gestionăm clusterul Kubernetes (orchestratorul de containere) din API-ul său, iar nodurile de lucru sunt nodurile pe care vor rula podurile sau containerele (Docker în cazul nostru). 


Vom presupune că cele 3 instanțe CentOS 7 sunt deja implementate și că aveți acces ssh la ele pentru a executa comenzile care vor urma.


Iată configurația pe care o avem în exemplul nostru și care va fi folosită ca exemplu pe parcursul acestei proceduri:


Nod master: "k8s-master" / 10.1.1.1.16<br>
Primul nod lucrător: "k8s-worker01" / 10.1.1.169<br>
Al doilea nod lucrător: "k8s-worker02" / 10.1.1.1.87<br>


== Tutorial de pregătire a sistemului și instalare Kubernetes ==

Următoarele acțiuni trebuie să fie efectuate pe toate instanțele (master și workers) ca root (sau cu drepturile sudo necesare).


Începeți prin completarea fișierului /etc/hosts pe fiecare dintre instanțele dvs., astfel încât acestea să poată rezolva numele de gazdă respectiv (în mod normal, acest lucru se întâmplă deja într-o rețea cu zonă avansată în care routerul virtual este un rezolvator DNS). 


În exemplul nostru, acest lucru dă următorul fișier /etc/hosts pe cele trei instanțe (adaptați-l cu numele și ip-ul instanțelor dvs.):

<syntaxhighlight lang="bash">
cat /etc/hosts
127.0.0.1   localhost
::1         localhost

10.1.1.16 k8s-master
10.1.1.169 k8s-worker01
10.1.1.87 k8s-worker02
</syntaxhighlight>


Activați modulul bridge și regulile iptables pentru acesta cu următoarele trei comenzi:

<syntaxhighlight lang="bash">
modprobe bridge
echo "net.bridge.bridge-nf-call-iptables = 1" >> /etc/sysctl.conf
sysctl -p /etc/sysctl.conf
</syntaxhighlight>


Adăugați depozitul YUM Docker :

<syntaxhighlight lang="bash">
cat <<EOF > /etc/yum.repos.d/docker.repo
[docker-ce-stable]
name=Docker CE Stable - \$basearch
baseurl=https://download.docker.com/linux/centos/7/\$basearch/stable
enabled=1
gpgcheck=1
gpgkey=https://download.docker.com/linux/centos/gpg
EOF
</syntaxhighlight>


Adăugați depozitul YUM Kubernetes : 

<syntaxhighlight lang="bash">
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg
        https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF
</syntaxhighlight>


Instalați Docker :

<syntaxhighlight lang="bash">
yum install -y docker-ce
</syntaxhighlight>


Apoi instalați pachetele Kubernetes necesare:

<syntaxhighlight lang="bash">
yum install -y kubeadm kubelet kubectl
</syntaxhighlight>


Editați fișierul de configurare al kubelet-ului systemd (/etc/systemd/system/kubelet.service.d/10-kubeadm.conf)  pentru a adăuga următoarea linie în secțiunea "[Service]":

<pre>
Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs"
</pre>


astfel încât :

<pre>
cat /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
# Note: This dropin only works with kubeadm and kubelet v1.11+
[Service]
Environment="KUBELET_KUBECONFIG_ARGS=--bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf"
Environment="KUBELET_CONFIG_ARGS=--config=/var/lib/kubelet/config.yaml"
*Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs"*
# This is a file that "kubeadm init" and "kubeadm join" generates at runtime, populating the KUBELET_KUBEADM_ARGS variable dynamically
EnvironmentFile=-/var/lib/kubelet/kubeadm-flags.env
# This is a file that the user can use for overrides of the kubelet args as a last resort. Preferably, the user should use
# the .NodeRegistration.KubeletExtraArgs object in the configuration files instead. KUBELET_EXTRA_ARGS should be sourced from this file.
EnvironmentFile=-/etc/sysconfig/kubelet
ExecStart=
ExecStart=/usr/bin/kubelet $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_KUBEADM_ARGS $KUBELET_EXTRA_ARGS
</pre>


Reîncărcați configurația, activați și apoi porniți serviciile docker și kubelet prin intermediul următoarelor trei comenzi:


systemctl daemon-reload
systemctl enable docker kubelet
systemctl start docker kubelet
</syntaxhighlight>


Dezactivați swap-ul de sistem (kubelet nu acceptă memoria swap, veți primi o eroare în timpul verificărilor pre-flight atunci când vă inițializați clusterul prin kubeadms dacă nu o dezactivați):

<syntaxhighlight lang="bash">
swapoff -a
</syntaxhighlight>


vă rugăm să nu uitați să comentați/eliminați și linia swap din fișierul /etc/fstab al fiecărei instanțe, cum ar fi :

<pre>
#/dev/mapper/vg01-swap  swap            swap    defaults                0       0
</pre>

== Inițializarea clusterului Kubernetes ==

Următoarele acțiuni trebuie efectuate numai pe instanța principală a nodului 


Începeți inițializarea clusterului Kubernetes prin intermediul comenzii de mai jos, având grijă să modificați valoarea parametrului "--apiserver-advertise-address=" cu adresa ip a instanței master.

<syntaxhighlight lang="bash">
kubeadm init --apiserver-advertise-address=<ip de votre instance master> --pod-network-cidr=10.244.0.0/16
</syntaxhighlight>

Notă: Vă rugăm să nu modificați ip-ul de rețea "10.244.0.0/16" indicat în parametrul "--pod-network-cidr=", deoarece acest parametru ne permite să indicăm că vom utiliza plugin-ul CNI Flannel pentru a gestiona partea de rețea a podurilor noastre.


Iată cum ar trebui să arate rezultatul acestei comenzi atunci când clusterul se inițializează cu succes:

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubeadm init --apiserver-advertise-address=10.1.1.16 --pod-network-cidr=10.244.0.0/16
[init] using Kubernetes version: v1.12.2
[preflight] running pre-flight checks
[preflight/images] Pulling images required for setting up a Kubernetes cluster
[preflight/images] This might take a minute or two, depending on the speed of your internet connection
[preflight/images] You can also perform this action in beforehand using 'kubeadm config images pull'
[kubelet] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[preflight] Activating the kubelet service
[certificates] Generated ca certificate and key.
[certificates] Generated apiserver-kubelet-client certificate and key.
[certificates] Generated apiserver certificate and key.
[certificates] apiserver serving cert is signed for DNS names [k8s-master.cs437cloud.internal kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 10.1.1.16]
[certificates] Generated front-proxy-ca certificate and key.
[certificates] Generated front-proxy-client certificate and key.
[certificates] Generated etcd/ca certificate and key.
[certificates] Generated etcd/server certificate and key.
[certificates] etcd/server serving cert is signed for DNS names [k8s-master.cs437cloud.internal localhost] and IPs [127.0.0.1 ::1]
[certificates] Generated etcd/peer certificate and key.
[certificates] etcd/peer serving cert is signed for DNS names [k8s-master.cs437cloud.internal localhost] and IPs [10.1.1.16 127.0.0.1 ::1]
[certificates] Generated etcd/healthcheck-client certificate and key.
[certificates] Generated apiserver-etcd-client certificate and key.
[certificates] valid certificates and keys now exist in "/etc/kubernetes/pki"
[certificates] Generated sa key and public key.
[kubeconfig] Wrote KubeConfig file to disk: "/etc/kubernetes/admin.conf"
[kubeconfig] Wrote KubeConfig file to disk: "/etc/kubernetes/kubelet.conf"
[kubeconfig] Wrote KubeConfig file to disk: "/etc/kubernetes/controller-manager.conf"
[kubeconfig] Wrote KubeConfig file to disk: "/etc/kubernetes/scheduler.conf"
[controlplane] wrote Static Pod manifest for component kube-apiserver to "/etc/kubernetes/manifests/kube-apiserver.yaml"
[controlplane] wrote Static Pod manifest for component kube-controller-manager to "/etc/kubernetes/manifests/kube-controller-manager.yaml"
[controlplane] wrote Static Pod manifest for component kube-scheduler to "/etc/kubernetes/manifests/kube-scheduler.yaml"
[etcd] Wrote Static Pod manifest for a local etcd instance to "/etc/kubernetes/manifests/etcd.yaml"
[init] waiting for the kubelet to boot up the control plane as Static Pods from directory "/etc/kubernetes/manifests"
[init] this might take a minute or longer if the control plane images have to be pulled
[apiclient] All control plane components are healthy after 32.502898 seconds
[uploadconfig] storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config-1.12" in namespace kube-system with the configuration for the kubelets in the cluster
[markmaster] Marking the node k8s-master.cs437cloud.internal as master by adding the label "node-role.kubernetes.io/master=''"
[markmaster] Marking the node k8s-master.cs437cloud.internal as master by adding the taints [node-role.kubernetes.io/master:NoSchedule]
[patchnode] Uploading the CRI Socket information "/var/run/dockershim.sock" to the Node API object "k8s-master.cs437cloud.internal" as an annotation
[bootstraptoken] using token: e83pes.u3igpccj2metetu8
[bootstraptoken] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstraptoken] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstraptoken] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstraptoken] creating the "cluster-info" ConfigMap in the "kube-public" namespace
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of machines by running the following on each node
as root:

  kubeadm join 10.1.1.16:6443 --token e83pes.u3igpccj2metetu8 --discovery-token-ca-cert-hash sha256:7ea9169bc5ac77b3a2ec37e5129006d9a895ce040e306f3093ce77e7422f7f1c
</syntaxhighlight>


Efectuăm operațiile solicitate pentru a finaliza inițializarea clusterului nostru:


Creăm un director și un fișier de configurare în directorul utilizatorului nostru (root în cazul nostru):

<syntaxhighlight lang="bash">
mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
</syntaxhighlight>


Implementăm rețeaua noastră de poduri Flannel pentru clusterul nostru:

<syntaxhighlight lang="bash">
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
clusterrole.rbac.authorization.k8s.io/flannel created
clusterrolebinding.rbac.authorization.k8s.io/flannel created
serviceaccount/flannel created
configmap/kube-flannel-cfg created
daemonset.extensions/kube-flannel-ds-amd64 created
daemonset.extensions/kube-flannel-ds-arm64 created
daemonset.extensions/kube-flannel-ds-arm created
daemonset.extensions/kube-flannel-ds-ppc64le created
daemonset.extensions/kube-flannel-ds-s390x created
</syntaxhighlight>

notă: vom păstra ultima comandă furnizată de întoarcerea comenzii de inițializare laterală ("kubeadm join...") pentru a o rula mai târziu pe instanțele noastre de lucrători pentru a le alătura la clusterul nostru.


Acum putem face primele verificări ale clusterului nostru de la instanța noastră principală:

Tastați comanda "kubectl get nodes" pentru a verifica nodurile prezente în prezent în clusterul dumneavoastră:

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get nodes
NAME                             STATUS   ROLES    AGE   VERSION
k8s-master.cs437cloud.internal   Ready    master   41m   v1.12.2
</syntaxhighlight>

Notă: în prezent există doar nodul principal, ceea ce este normal, deoarece nu am adăugat încă celelalte noduri la cluster.


Tastați comanda "kubectl get pods --all-namespaces" pentru a verifica podurile/containerele prezente în prezent în clusterul dumneavoastră: 

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get pods --all-namespaces
NAMESPACE     NAME                                                     READY   STATUS    RESTARTS   AGE
kube-system   coredns-576cbf47c7-fwxj9                                 1/1     Running   0          41m
kube-system   coredns-576cbf47c7-t86s9                                 1/1     Running   0          41m
kube-system   etcd-k8s-master.cs437cloud.internal                      1/1     Running   0          41m
kube-system   kube-apiserver-k8s-master.cs437cloud.internal            1/1     Running   0          41m
kube-system   kube-controller-manager-k8s-master.cs437cloud.internal   1/1     Running   0          41m
kube-system   kube-flannel-ds-amd64-wcm7v                              1/1     Running   0          84s
kube-system   kube-proxy-h94bs                                         1/1     Running   0          41m
kube-system   kube-scheduler-k8s-master.cs437cloud.internal            1/1     Running   0          40m
</syntaxhighlight>

Notă: Există doar poduri corespunzătoare componentelor Kubernetes necesare pentru nodul nostru principal (kube-apiserver, etcd, kube-scheduler etc.).


Putem verifica starea acestor componente cu următoarea comandă:

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get cs
NAME                 STATUS    MESSAGE              ERROR
scheduler            Healthy   ok
controller-manager   Healthy   ok
etcd-0               Healthy   {"health": "true"}
</syntaxhighlight>

== Adăugarea nodurilor de lucru la cluster ==

Acțiuni care urmează să fie efectuate numai pe instanțele/nodurile lucrătoare

Pe fiecare dintre instanțele worker (nu o faceți pe instanța master), rulați comanda "kubeadm join ..." furnizată la sfârșitul inițializării clusterului de mai sus:

<syntaxhighlight lang="bash">
[root@k8s-worker01 ~]# kubeadm join 10.1.1.16:6443 --token e83pes.u3igpccj2metetu8 --discovery-token-ca-cert-hash sha256:7ea9169bc5ac77b3a2ec37e5129006d9a895ce040e306f3093ce77e7422f7f1c
[preflight] running pre-flight checks
        [WARNING RequiredIPVSKernelModulesAvailable]: the IPVS proxier will not be used, because the following required kernel modules are not loaded: [ip_vs_sh ip_vs ip_vs_rr ip_vs_wrr] or no builtin kernel ipvs support: map[ip_vs:{} ip_vs_rr:{} ip_vs_wrr:{} ip_vs_sh:{} nf_conntrack_ipv4:{}]
you can solve this problem with following methods:
 1. Run 'modprobe -- ' to load missing kernel modules;
2. Provide the missing builtin kernel ipvs support

[discovery] Trying to connect to API Server "10.1.1.16:6443"
[discovery] Created cluster-info discovery client, requesting info from "https://10.1.1.16:6443"
[discovery] Requesting info from "https://10.1.1.16:6443" again to validate TLS against the pinned public key
[discovery] Cluster info signature and contents are valid and TLS certificate validates against pinned roots, will use API Server "10.1.1.16:6443"
[discovery] Successfully established connection with API Server "10.1.1.16:6443"
[kubelet] Downloading configuration for the kubelet from the "kubelet-config-1.12" ConfigMap in the kube-system namespace
[kubelet] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[preflight] Activating the kubelet service
[tlsbootstrap] Waiting for the kubelet to perform the TLS Bootstrap...
[patchnode] Uploading the CRI Socket information "/var/run/dockershim.sock" to the Node API object "k8s-worker01.cs437cloud.internal" as an annotation

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the master to see this node join the cluster.
</syntaxhighlight>

<syntaxhighlight lang="bash">
[root@k8s-worker02 ~]# kubeadm join 10.1.1.16:6443 --token e83pes.u3igpccj2metetu8 --discovery-token-ca-cert-hash sha256:7ea9169bc5ac77b3a2ec37e5129006d9a895ce040e306f3093ce77e7422f7f1c
[preflight] running pre-flight checks
        [WARNING RequiredIPVSKernelModulesAvailable]: the IPVS proxier will not be used, because the following required kernel modules are not loaded: [ip_vs_wrr ip_vs_sh ip_vs ip_vs_rr] or no builtin kernel ipvs support: map[ip_vs:{} ip_vs_rr:{} ip_vs_wrr:{} ip_vs_sh:{} nf_conntrack_ipv4:{}]
you can solve this problem with following methods:
 1. Run 'modprobe -- ' to load missing kernel modules;
2. Provide the missing builtin kernel ipvs support

[discovery] Trying to connect to API Server "10.1.1.16:6443"
[discovery] Created cluster-info discovery client, requesting info from "https://10.1.1.16:6443"
[discovery] Requesting info from "https://10.1.1.16:6443" again to validate TLS against the pinned public key
[discovery] Cluster info signature and contents are valid and TLS certificate validates against pinned roots, will use API Server "10.1.1.16:6443"
[discovery] Successfully established connection with API Server "10.1.1.16:6443"
[kubelet] Downloading configuration for the kubelet from the "kubelet-config-1.12" ConfigMap in the kube-system namespace
[kubelet] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[preflight] Activating the kubelet service
[tlsbootstrap] Waiting for the kubelet to perform the TLS Bootstrap...
[patchnode] Uploading the CRI Socket information "/var/run/dockershim.sock" to the Node API object "k8s-worker02.cs437cloud.internal" as an annotation

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the master to see this node join the cluster.
</syntaxhighlight>

== Verificarea stării clusterului  ==

Acțiuni care urmează să fie efectuate de la instanța/nodul principal


Verificați dacă nodurile de lucru au fost adăugate la clusterul dvs. prin re-executarea comenzii "kubectl get nodes":

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get nodes
NAME                               STATUS   ROLES    AGE    VERSION
k8s-master.cs437cloud.internal     Ready    master   46m    v1.12.2
k8s-worker01.cs437cloud.internal   Ready    <none>   103s   v1.12.2
k8s-worker02.cs437cloud.internal   Ready    <none>   48s    v1.12.2
</syntaxhighlight>

Observație : Putem vedea cele două noduri de lucru (k8s-worker01 și k8s-worker02), deci au fost adăugate la clusterul nostru.


Acum să rulăm din nou comanda "kubectl get pods --all-namespaces":

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get pods --all-namespaces
NAMESPACE     NAME                                                     READY   STATUS    RESTARTS   AGE
kube-system   coredns-576cbf47c7-fwxj9                                 1/1     Running   0          46m
kube-system   coredns-576cbf47c7-t86s9                                 1/1     Running   0          46m
kube-system   etcd-k8s-master.cs437cloud.internal                      1/1     Running   0          46m
kube-system   kube-apiserver-k8s-master.cs437cloud.internal            1/1     Running   0          46m
kube-system   kube-controller-manager-k8s-master.cs437cloud.internal   1/1     Running   0          46m
kube-system   kube-flannel-ds-amd64-724nl                              1/1     Running   0          2m6s
kube-system   kube-flannel-ds-amd64-wcm7v                              1/1     Running   0          6m31s
kube-system   kube-flannel-ds-amd64-z7mwg                              1/1     Running   3          70s
kube-system   kube-proxy-8r7wg                                         1/1     Running   0          2m6s
kube-system   kube-proxy-h94bs                                         1/1     Running   0          46m
kube-system   kube-proxy-m2f5r                                         1/1     Running   0          70s
kube-system   kube-scheduler-k8s-master.cs437cloud.internal            1/1     Running   0          46m
</syntaxhighlight>

Notă: Puteți vedea că există atâtea poduri/containere "kube-flannel" și "kube-proxy" câte noduri avem în clusterul nostru.

== Implementarea unei prime capsule ==

Vom desfășura primul nostru [https://kubernetes.io/docs/concepts/workloads/pods/pod/ pod] în clusterul nostru Kubernetes.


Pentru simplitate, alegem să implementăm un pod (fără replici) numit "nginx" și să folosim imaginea "nginx":

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl create deployment nginx --image=nginx
deployment.apps/nginx created
</syntaxhighlight>


Dacă verificăm, acesta apare bine la întoarcerea comenzii care listează podurile din clusterul nostru:

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get pods --all-namespaces
NAMESPACE     NAME                                                     READY   STATUS    RESTARTS   AGE
default       nginx-55bd7c9fd-5bghl                                    1/1     Running   0          104s
kube-system   coredns-576cbf47c7-fwxj9                                 1/1     Running   0          57m
kube-system   coredns-576cbf47c7-t86s9                                 1/1     Running   0          57m
kube-system   etcd-k8s-master.cs437cloud.internal                      1/1     Running   0          57m
kube-system   kube-apiserver-k8s-master.cs437cloud.internal            1/1     Running   0          57m
kube-system   kube-controller-manager-k8s-master.cs437cloud.internal   1/1     Running   0          57m
kube-system   kube-flannel-ds-amd64-724nl                              1/1     Running   0          13m
kube-system   kube-flannel-ds-amd64-wcm7v                              1/1     Running   0          17m
kube-system   kube-flannel-ds-amd64-z7mwg                              1/1     Running   3          12m
kube-system   kube-proxy-8r7wg                                         1/1     Running   0          13m
kube-system   kube-proxy-h94bs                                         1/1     Running   0          57m
kube-system   kube-proxy-m2f5r                                         1/1     Running   0          12m
kube-system   kube-scheduler-k8s-master.cs437cloud.internal            1/1     Running   0          57m
</syntaxhighlight>

Acesta apare în partea de sus a listei într-un spațiu de nume diferit de "kube-system", deoarece nu este o componentă specifică funcționării Kubernetes.


De asemenea, este posibil să se evite afișarea podurilor specifice spațiului de nume kube-system prin executarea acestei comenzi fără parametrul "--all-namespace":

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get pods
NAME                      READY   STATUS    RESTARTS   AGE
nginx-55bd7c9fd-vs4fq     1/1     Running   0          3d2h
</syntaxhighlight>


Pentru a afișa etichetele :

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get pods --show-labels
NAME                      READY   STATUS    RESTARTS   AGE    LABELS
nginx-55bd7c9fd-ckltn     1/1     Running   0          8m2s   app=nginx,pod-template-hash=55bd7c9fd
</syntaxhighlight>


De asemenea, putem verifica implementările noastre cu următoarea comandă:

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get deployments
NAME    DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx   1         1         1            1           93m
</syntaxhighlight>


Deci, avem un pod nginx implementat și pornit, dar nu este încă accesibil din exterior. Pentru a-l face accesibil din exterior, trebuie să expunem portul podului nostru prin crearea serviciului (de tip NodePort) prin următoarea comandă:

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl create service nodeport nginx --tcp=80:80
service/nginx created
</syntaxhighlight>


Serviciul nostru este astfel creat:

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get svc
NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1        <none>        443/TCP        147m
nginx        NodePort    10.108.251.178   <none>        80:30566/TCP   20s
</syntaxhighlight>

Notă: Ascultă pe portul 80/tcp și va fi disponibil/expus din exterior pe portul 30566/tcp.


Putem obține ip-ul flannel al podului nostru și numele nodului pe care rulează în prezent prin intermediul următoarei comenzi:

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl get pods --selector="app=nginx" --output=wide
NAME                    READY   STATUS    RESTARTS   AGE    IP           NODE                               NOMINATED NODE
nginx-55bd7c9fd-vs4fq   1/1     Running   0          174m   10.244.2.2   k8s-worker02.cs437cloud.internal   <none>
</syntaxhighlight>

Aici, podul nostru nginx are ip 10.244.2.2.2 și rulează pe nodul nostru k8s-worker02.


De asemenea, puteți rula pur și simplu o comandă sau deschide un shell pe podul nostru nginx prin intermediul următoarei comenzi (foarte asemănătoare cu comanda docker):

<syntaxhighlight lang="bash">
[root@k8s-master ~]# kubectl exec -it nginx-55bd7c9fd-vs4fq -- /bin/bash
root@nginx-55bd7c9fd-vs4fq:/#
</syntaxhighlight>


Tot ce trebuie să faceți este să creați regula de echilibrare a încărcăturii pe rețeaua Ikoula One Cloud pentru a accesa / face public serverul dvs. web (pod nginx):

- Conectați-vă la [https://cloudstack.ikoula.com/client Nor Ikoula One]

- mergeți la "Rețea" în meniul vertical din stânga

- faceți clic pe rețeaua în care ați implementat instanțele Kubernetes, apoi pe "View IP Addresses" și pe IP-ul sursă NAT și mergeți la fila "Configuration".

- faceți clic pe "Load Balancing" și creați regula dvs. specificând un nume, portul public "80" în cazul nostru, portul privat "30566" în cazul nostru (vezi mai sus), alegând un algoritm LB (de exemplu, round-robin), cum ar fi :


[[File:faq_k8s_regle_lb-01.png|Instanța Kubernetes]]


- bifați toate instanțele de lucrător:


[[File:faq_k8s_regle_lb-02.png|Verificați instanțele de lucru kubernetes]]



Testați accesul la serverul dvs. web / podul nginx din browser (prin intermediul ip-ului public al rețelei dvs. pe care ați creat regula LB):


[[File:faq_k8s_browser_nginx.png|Acces la serverul dvs. web]]


Faptul că podul nginx poate fi accesat de pe oricare dintre nodurile dvs. este posibil datorită componentei "kube-proxy", care este responsabilă de direcționarea conexiunilor către nodul (nodurile) pe care rulează (în cazul replicilor).


Deci, tocmai ați implementat un cluster Kubernetes de bază de 3 noduri cu un master și doi workers.

== Mergeți mai departe ==

Puteți merge mai departe prin implementarea tabloului de bord Kubernetes sau prin crearea de volume persistente pentru podurile dvs., prin creșterea numărului de noduri de lucru sau chiar prin atribuirea redundantă a rolului de maestru pentru o disponibilitate ridicată sau prin dedicarea nodurilor pentru anumite componente, cum ar fi Etcd, de exemplu. 


Iată câteva linkuri utile:


https://kubernetes.io/docs/reference/kubectl/cheatsheet/ 

https://kubernetes.io/docs/reference/kubectl/docker-cli-to-kubectl/

https://kubernetes.io/docs/concepts/storage/volumes/

https://kubernetes.io/docs/tasks/configure-pod-container/configure-persistent-volume-storage/

https://kubernetes.io/docs/tasks/access-application-cluster/communicate-containers-same-pod-shared-volume/

https://kubernetes.io/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/



[[Category:cloudstack]]
[[Category:cloud public]]
[[Category:cloud privat]]
[[Category:Docker]]
[[Category:CoreOS]]
[[Category:Cloud]]