🥇 Minimum Viable Kubernetes

Versio articuli praeparata est pervigilio initii "DevOps exercitia et instrumenta".

Si hoc legistis, aliquid de Kubernetes probabiliter audisti (et si non, quomodo hic tandem es?) Sed quidnam Kubernetes? Hoc "Orchestratio industrialis-gradus continentia"? Or "Cloud-Natio Operating System"? Quid etiam hoc sibi vult?

Probus esse, non sum certus C%. Sed puto suus interesting fodere in interna et videre quid vere agatur in Kubernetes sub multis eius stratis abstractorum. Ita pro ioco, inspice quod minimum “Kubernetes botrus” actu similis est. (Hoc multo facilius erit quam Kubernetes The Hard Way.)

Suppono tibi Kubernetes, Linux, et continentes praecipuas notiones habere. Omnia quae hic loquimur, solum ad investigationes/disciplinas usus pertinet, nihil ex eo in productionem ponimus!

Overview

Kubernetes multa continet. Secundum wikipedia,architectonica similis est:

Sunt saltem octo partes hic ostensae, sed plurimas ignorabimus. Volo dicere rem minimam quae rationabiliter Kubernetes vocari potest, tribus principalibus componentibus consistere:

cubelet
kube-apiserver (quod pendet ab etc. - ejus database)
continens runtime (Docker in hoc casu)

Videamus quid de singulis illis documentis dicat.tus., Anglicus.). Primo cubelet:

Agens nodi in botro currit. Facit certa vasa currere in vasculum.

Simplex sonat satis. Quid de continens runtimes (continens runtime)?

Continens runtime programmata est ad vasa currendam destinata.

Valde informativus. Sed si cum Docker nota es, tunc generalem notionem habere debes. (Singula separationis officiorum inter runtime et kubeletum continens actu admodum subtilia sunt et huc in illas non ingrediar).

И API server?

API Servo est Kubernetes tabelli dicione componentes qui Kubernetes API exponit. API servulus clientis lateris Kubernetorum panel imperium est

Quisquis unquam aliquid cum Kubernetes egit, cum API vel per se vel per kubectl penitus se habuit. Hoc cor facit Kubernetes Kubernetes - cerebrum quod montes YAML vertit, omnes nos scimus et amant (?) ad infrastructuram operandam. Videtur evidens API adesse in nostra configuratione minima.

Preconditions

Linux machinae virtualis vel physicae cum accessu radicis (Ubuntu 18.04 in machina virtuali usus sum).
Et actum est?

Odiosis institutionem

Opus Docker in machina utemur. (Im 'non iturus in detail quomodo Docker et vasa opuscula; si es interested, illic est mira vasa). Lets iustus install is cum apt:

$ sudo apt install docker.io
$ sudo systemctl start docker

Post hoc opus est binarios Kubernetes obtinere. Re vera, ad primam sollicitudinem nostri "botrus" tantum opus est kubelet, quia currere aliis componentibus servo uti possumus kubelet. Ad botrum nostrum penitus postquam currit, etiam utemur kubectl.

$ curl -L https://dl.k8s.io/v1.18.5/kubernetes-server-linux-amd64.tar.gz > server.tar.gz
$ tar xzvf server.tar.gz
$ cp kubernetes/server/bin/kubelet .
$ cp kubernetes/server/bin/kubectl .
$ ./kubelet --version
Kubernetes v1.18.5

Quid accidit, si modo currunt? kubelet?

$ ./kubelet
F0609 04:03:29.105194    4583 server.go:254] mkdir /var/lib/kubelet: permission denied

kubelet ut radix currere debet. Plane consentaneum est, cum totam node administrare opus sit. Intueamur ejus parametri:

$ ./kubelet -h
<слишком много строк, чтобы разместить здесь>
$ ./kubelet -h | wc -l
284

Wow, tot bene! Feliciter duobus tantum opus est. Hic est unus ex parametris quos interroget:

--pod-manifest-path string

Semita in indicem continens lima pro legumine static, vel semita ad limam siliquam static describendam. Tabulae incipiens cum punctis neglectis. (DEPRECATED: Haec optio ponenda est in lima configuratione lata ad optionem Kubelet per --config. Pro magis notitia, vide kubernetes.io/docs/tasks/administer-botrus/kubelet-config-file .)

Haec optio nobis concedit currere static siliquae — Siliquae quae per Kubernetes API non administrantur. Siliquae staticae raro adhibentur, sed commodissimae sunt ad racemum celeriter levandum, et hoc prorsus opus est. Magnam hanc admonitionem latebimus (iterum, noli hoc in productione currere!) et vide si vasculum currendo consequi possumus.

Primum directorium creabimus siliquae statice et currendo kubelet:

$ mkdir pods
$ sudo ./kubelet --pod-manifest-path=pods

Deinde in alia terminali/tmux fenestra quidquid, vasculum manifestum creabimus;

$ cat <<EOF > pods/hello.yaml
apiVersion: v1
kind: Pod
metadata:
  name: hello
spec:
  containers:
  - image: busybox
    name: hello
    command: ["echo", "hello world!"]
EOF

kubelet incipit scribere quaedam monita et videtur quasi nihil agatur. Sed hoc non est verum! Intueamur Docker:

$ sudo docker ps -a
CONTAINER ID        IMAGE                  COMMAND                 CREATED             STATUS                      PORTS               NAMES
8c8a35e26663        busybox                "echo 'hello world!'"   36 seconds ago      Exited (0) 36 seconds ago                       k8s_hello_hello-mink8s_default_ab61ef0307c6e0dee2ab05dc1ff94812_4
68f670c3c85f        k8s.gcr.io/pause:3.2   "/pause"                2 minutes ago       Up 2 minutes                                    k8s_POD_hello-mink8s_default_ab61ef0307c6e0dee2ab05dc1ff94812_0
$ sudo docker logs k8s_hello_hello-mink8s_default_ab61ef0307c6e0dee2ab05dc1ff94812_4
hello world!

kubelet Vasculum legi manifestum et mandatum Docker dedit ut duo vasa ad nostras specificationes mitteret. (Si miraris de receptaculo "pausae", suus Kubernetes scidit - vide hoc blog.) Kubelet continens nostrum mittet busybox cum mandato praefinito et in infinitum sileo donec vasculum static deletum est.

Gratulor tibi. Modo ascendimus cum uno ex maxime confusissimis modis ad output text terminatio!

Lorem etc

Propositum nostrum ultimum est Kubernetes API currere, sed facere ut primum opus sit etc. Incipiamus botrum minimi etcd ponendo suos occasus in siliquae directorio (exempli gratia: pods/etcd.yaml):

apiVersion: v1
kind: Pod
metadata:
  name: etcd
  namespace: kube-system
spec:
  containers:
  - name: etcd
    command:
    - etcd
    - --data-dir=/var/lib/etcd
    image: k8s.gcr.io/etcd:3.4.3-0
    volumeMounts:
    - mountPath: /var/lib/etcd
      name: etcd-data
  hostNetwork: true
  volumes:
  - hostPath:
      path: /var/lib/etcd
      type: DirectoryOrCreate
    name: etcd-data

Si umquam cum Kubernetibus laboravi, haec fasciculi YAML tibi nota esse debent. Duo tantum puncta hic notanda sunt;

Nos exercitum folder conscendimus /var/lib/etcd in vasculo ita ut notitia etcd post sileo conservata sit (si hoc non fit, glomus status delebitur omni tempore vasculum restiletur, quod etiam minimum Kubernetes institutioni non erit bonum).

Nos have installed hostNetwork: true. Hic occasus, unsurprisingly, configurat etcd utatur retis ornatus pro retis vasculi interni (hoc facilius faciet pro servo API etcd botrum inveniendum).

Simplex perscriptio ostendit quod etcd quidem currit in localhost et notitia salutaris ad disci;

$ curl localhost:2379/version
{"etcdserver":"3.4.3","etcdcluster":"3.4.0"}
$ sudo tree /var/lib/etcd/
/var/lib/etcd/
└── member
    ├── snap
    │   └── db
    └── wal
        ├── 0.tmp
        └── 0000000000000000-0000000000000000.wal

Satus API server

Cursor a Kubernetes API servo facilior etiam est. Solus parameter, quod praetermittendum est --etcd-serversagit quod exspectas;

apiVersion: v1
kind: Pod
metadata:
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
  - name: kube-apiserver
    command:
    - kube-apiserver
    - --etcd-servers=http://127.0.0.1:2379
    image: k8s.gcr.io/kube-apiserver:v1.18.5
  hostNetwork: true

YAML pone hunc fasciculum in indicem podsac API servo incipiet. Reprehendo cum curl Ostendit Kubernetes API audisse in portu 8080 cum accessu penitus aperto - nullam authenticationem requiri!

$ curl localhost:8080/healthz
ok
$ curl localhost:8080/api/v1/pods
{
  "kind": "PodList",
  "apiVersion": "v1",
  "metadata": {
    "selfLink": "/api/v1/pods",
    "resourceVersion": "59"
  },
  "items": []
}

(Iterum, noli hoc in productione currere! Paululum miratus sum quod defectus occasus tam incertus est. Sed coniecturam facio facilius progressionem facere et experiri.)

Et, iucunde mirum, opera e cista kubectl sine ullo addito fundis!

$ ./kubectl version
Client Version: version.Info{Major:"1", Minor:"18", GitVersion:"v1.18.5", GitCommit:"e6503f8d8f769ace2f338794c914a96fc335df0f", GitTreeState:"clean", BuildDate:"2020-06-26T03:47:41Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"18", GitVersion:"v1.18.5", GitCommit:"e6503f8d8f769ace2f338794c914a96fc335df0f", GitTreeState:"clean", BuildDate:"2020-06-26T03:39:24Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}
$ ./kubectl get pod
No resources found in default namespace.

quaestio

Sed si paulo altius fodes, videtur aliquid errare;

$ ./kubectl get pod -n kube-system
No resources found in kube-system namespace.

Siliquae statice, quae creatae sunt, abiit! Revera noster kubelet nodi omnino non reperitur;

$ ./kubectl get nodes
No resources found in default namespace.

Quid rei est? Si paucas paragraphos ante meministi, kubeletum cum praecepto lineae parametri praecepti admodum simplex incepimus, ergo kubelet nescit quomodo contactum API servo suo de statu suo certiorem faciat. Post documenta cognita, vexillum respondente invenimus:

--kubeconfig string

Semita ad tabella kubeconfig, qui dat connectere cum API servo. Availability --kubeconfig dat API servo modus, no --kubeconfig dat online modus.

Hoc totum tempus, illud nescientes, kubelet in "modo offline" currebamus. (Si pedantici essemus, cogitare possemus de standalone kubeleti ut "minimum viable Kubernetes", sed id valde taediosum esset). Ut "realis" figuratio operis efficiatur, necesse est tabellam kubeconfig ad kubelet transire ut sciat quomodo cum API servo loqui. Feliciter suus 'simplex' (quia nullas authenticas vel certificatorias quaestiones habemus);

apiVersion: v1
kind: Config
clusters:
- cluster:
    server: http://127.0.0.1:8080
  name: mink8s
contexts:
- context:
    cluster: mink8s
  name: mink8s
current-context: mink8s

Hoc pro kubeconfig.yamlOccide processum kubelet et sileo cum parametris necessariis;

$ sudo ./kubelet --pod-manifest-path=pods --kubeconfig=kubeconfig.yaml

(Per viam, si ad API per Crispum accedere coneris cum kubelet non currit, adhuc currere invenies! Kubelet non est "parens" sui siliquae sicut Docker, sed "imperium" similior est. daemonem." Vasa a kubelet tractata pergit currere donec kubelet sistit eos).

In paucis minutis kubectl siliquas nodosque nobis ostendat sicut speramus;

$ ./kubectl get pods -A
NAMESPACE     NAME                    READY   STATUS             RESTARTS   AGE
default       hello-mink8s            0/1     CrashLoopBackOff   261        21h
kube-system   etcd-mink8s             1/1     Running            0          21h
kube-system   kube-apiserver-mink8s   1/1     Running            0          21h
$ ./kubectl get nodes -owide
NAME     STATUS   ROLES    AGE   VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION       CONTAINER-RUNTIME
mink8s   Ready    <none>   21h   v1.18.5   10.70.10.228   <none>        Ubuntu 18.04.4 LTS   4.15.0-109-generic   docker://19.3.6

Gratulemur nobis hoc tempore (scio me iam nosmet ipsos gratulari) minimum Kubernetes "botrus" currentes cum API plene functionis habemus!

Nos sub launch

Nunc videamus quid API capax sit. Sit scriptor initium nginx vasculum;

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx

Hic potius interesting erroris accipitur:

$ ./kubectl apply -f nginx.yaml
Error from server (Forbidden): error when creating "nginx.yaml": pods "nginx" is
forbidden: error looking up service account default/default: serviceaccount
"default" not found
$ ./kubectl get serviceaccounts
No resources found in default namespace.

Hic videmus quam flebiliter incompleta sit ambitus nostri Kubernetes - nullas habemus rationes officiorum. Experiamur iterum per manually partum officii rationem et vide quid accidit;

$ cat <<EOS | ./kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: default
  namespace: default
EOS
serviceaccount/default created
$ ./kubectl apply -f nginx.yaml
Error from server (ServerTimeout): error when creating "nginx.yaml": No API
token found for service account "default", retry after the token is
automatically created and added to the service account

Etiam cum servitium manually creavimus, signum authenticationis non generatur. Cum experimenta pergamus cum nostris minimis "botrus", inveniemus pleraque utilissima quae sponte evenire solent deesse. Kubernetes API cultor admodum minimalisticus est, cum plerisque gravibus sublationis et automatice configurationibus eventis in variis moderatoribus et in background jobs qui nondum currentes sunt.

Circa hanc quaestionem possumus operari per optionem ad occasum automountServiceAccountToken ad rationem officii (quoniam ea usquam uti non habemus);

$ cat <<EOS | ./kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: default
  namespace: default
automountServiceAccountToken: false
EOS
serviceaccount/default configured
$ ./kubectl apply -f nginx.yaml
pod/nginx created
$ ./kubectl get pods
NAME    READY   STATUS    RESTARTS   AGE
nginx   0/1     Pending   0          13m

Denique vasculum apparuit! At re vera non incipiet quia non habemus consiliumque (scheduler) alia magni ponderis pars Kubernetes est. Rursum videmus Kubernetes API mire "mutum" esse - cum Podex in API creas, illud perscriptum est, sed id quod nodi persequi non conetur instare.

Re vera non opus est schedula ad currendum. Nodi manifesto in parametro addere potes manually nodeName:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
  nodeName: mink8s

(Restituo mink8s ad nomen nodi.) Postquam delere et applicare, nginx incepit et audit internam IP oratio:

$ ./kubectl delete pod nginx
pod "nginx" deleted
$ ./kubectl apply -f nginx.yaml
pod/nginx created
$ ./kubectl get pods -owide
NAME    READY   STATUS    RESTARTS   AGE   IP           NODE     NOMINATED NODE   READINESS GATES
nginx   1/1     Running   0          30s   172.17.0.2   mink8s   <none>           <none>
$ curl -s 172.17.0.2 | head -4
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>

Fac ut retis inter siliquas recte laborat, cincinnum ex alio vasculo currere possumus:

$ cat <<EOS | ./kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: curl
spec:
  containers:
  - image: curlimages/curl
    name: curl
    command: ["curl", "172.17.0.2"]
  nodeName: mink8s
EOS
pod/curl created
$ ./kubectl logs curl | head -6
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>

Est admodum interesting fodere in hoc ambitu ac videre quid opera et quid non. ConfigMap et opus Secretum ut expectatur inveni, sed Service et instruere non.

Prosperitas!

Haec posts longa est, ideo victoriam nuntiaturus sum et dico hanc esse figuram viabilem quae "Kubernetes" dici potest. Ad summatim: quattuor binaria, quinque lineae parametri mandata et "tantum" 45 lineas YAML (non quod multa signa Kubernetes) et nos satis pauca operati sumus;

Siliquae administrantur in usu regulari Kubernetes API (cum paucis hacks)
Potes upload et administrare continens imagines publicas
Siliquae vivae et automatice sileo
Networking inter siliquas in eodem nodi bene operatur
ConfigMap, Secretum et simplex opus repositionis adscendens ut expectata

Sed multa ex iis quae Kubernetes vere utiles facit, adhuc desunt, ut:

Pod Scheduler
Authenticas / auctoritas
Nodorum multiplex
Network of services
DNS conglobata internus
Moderatores ad rationes muneris, instruere, integratio cum provisoribus nubecularum et maxime aliarum lacus quas Kubernetes affert.

Quid ergo habemus actu? Kubernetes API, sua sponte currentes, suggestum vere justum est continens automation. Non multum facit - officium est variis moderatoris et operariorum API utentibus - sed dat congruentem ambitum automationis.

Plura de cursus in libero webinar.

Lege plus:

Source: www.habr.com

Minimum Viable Kubernetes