Ikbot: Pagină nouă: :fr:Deployer un cluster Kubernetesfr:D...

2021-07-29T14:01:56Z

Pagină nouă: fr:Deployer un cluster Kubernetesfr:D...

Pagină nouă

[[:fr:Deployer un cluster Kubernetes]][[fr:Deployer un cluster Kubernetes]]
 Acest articol este rezultatul unei traduceri automate efectuate de către software-ul. Puteți vizualiza sursa articol [[:fr:Array|aici]]. 
[[:ru:Развертывание кластера Kubernetes]][[ru:Развертывание кластера Kubernetes]]
[[:pl:Wdrażanie klastra Kubernetes]][[pl:Wdrażanie klastra Kubernetes]]
[[:ja:Kubernetesクラスタのデプロイ]][[ja:Kubernetesクラスタのデプロイ]]
[[:zh:部署一个Kubernetes集群]][[zh:部署一个Kubernetes集群]]
[[:de:Bereitstellen eines Kubernetes-Clusters]][[de:Bereitstellen eines Kubernetes-Clusters]]
[[:nl:Een Kubernetes cluster implementeren]][[nl:Een Kubernetes cluster implementeren]]
[[:pt:Implantação de um aglomerado Kubernetes]][[pt:Implantação de um aglomerado Kubernetes]]
[[:es:Despliegue de un clúster Kubernetes]][[es:Despliegue de un clúster Kubernetes]]
[[:en:Deploying a Kubernetes cluster]][[en:Deploying a Kubernetes cluster]]
[[:it:Configurare un cluster Kubernetes]][[it:Configurare un cluster Kubernetes]]
[[: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?==

'''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.com/fr/cloud-public/oneclick 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 
Primul nod lucrător: "k8s-worker01" / 10.1.1.169 
Al doilea nod lucrător: "k8s-worker02" / 10.1.1.1.87 

== 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]]

Implementarea unui cluster Kubernetes - Revizia istoricului

Cbrochot1072d la 28 octombrie 2021 14:36

Ikbot: Pagină nouă: :fr:Deployer un cluster Kubernetesfr:D...

@@ Linia 25: / Linia 25: @@
 ==Ce este Kubernetes?==
-'''Kubernetes''' este o platformă open-source pentru gestionarea sarcinilor de lucru și a serviciilor containerizate.
+'''[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.com/fr/cloud-public/oneclick 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.
+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.