Implementarea unui 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 aici.

ru:Развертывание кластера Kubernetes pl:Wdrażanie klastra Kubernetes ja:Kubernetesクラスタのデプロイ zh:部署一个Kubernetes集群 de:Bereitstellen eines Kubernetes-Clusters nl:Een Kubernetes cluster implementeren pt:Implantação de um aglomerado Kubernetes es:Despliegue de un clúster Kubernetes en:Deploying a Kubernetes cluster it:Configurare un cluster Kubernetes fr:Deployer un cluster Kubernetes

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. 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.):

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

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

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

Adăugați depozitul YUM Docker :

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

Adăugați depozitul YUM Kubernetes :

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

Instalați Docker :

yum install -y docker-ce

Apoi instalați pachetele Kubernetes necesare:

yum install -y kubeadm kubelet kubectl

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]":

Environment="KUBELET_CGROUP_ARGS=--cgroup-driver=cgroupfs"

astfel încât :

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

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):

swapoff -a

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 :

#/dev/mapper/vg01-swap  swap            swap    defaults                0       0

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.

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

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:

[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

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):

mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

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

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

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ă:

[root@k8s-master ~]# kubectl get nodes
NAME                             STATUS   ROLES    AGE   VERSION
k8s-master.cs437cloud.internal   Ready    master   41m   v1.12.2

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ă:

[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

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ă:

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

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:

[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.

[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.

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

[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

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

[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

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 pod în clusterul nostru Kubernetes.

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

[root@k8s-master ~]# kubectl create deployment nginx --image=nginx
deployment.apps/nginx created

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

[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

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

[root@k8s-master ~]# kubectl get pods
NAME                      READY   STATUS    RESTARTS   AGE
nginx-55bd7c9fd-vs4fq     1/1     Running   0          3d2h

Pentru a afișa etichetele :

[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

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

[root@k8s-master ~]# kubectl get deployments
NAME    DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx   1         1         1            1           93m

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ă:

[root@k8s-master ~]# kubectl create service nodeport nginx --tcp=80:80
service/nginx created

Serviciul nostru este astfel creat:

[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

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:

[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>

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):

[root@k8s-master ~]# kubectl exec -it nginx-55bd7c9fd-vs4fq -- /bin/bash
root@nginx-55bd7c9fd-vs4fq:/#

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 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 :

Instanța Kubernetes

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

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):

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/