1~
2Daca lucrezi in lumea dezvoltarii software, cu siguranta ai auzit de Kubernetes. Dar ce este exact si de ce a devenit standardul de facto pentru gestionarea aplicatiilor containerizate? Acest ghid te va duce de la baze la conceptele fundamentale, cu exemple practice si diagrame pentru a te ajuta sa intelegi.
3~
4## Inainte de Kubernetes: Un pic de istorie
5~
6Pentru a intelege de ce Kubernetes este atat de revolutionar, sa facem un pas inapoi.
7~
81.  **Implementare traditionala**: Initial, aplicatiile rulau pe servere fizice. Aceasta abordare era costisitoare, dificil de scalat si predispusa la conflicte de resurse.
92.  **Implementare virtualizata**: Apoi au aparut masinile virtuale (VM). VM-urile au permis mai multor aplicatii izolate sa ruleze pe acelasi hardware, imbunatatind utilizarea resurselor si securitatea. Totusi, fiecare VM ruleaza un sistem de operare complet, consumand multe resurse.
103.  **Implementare containerizata**: Containerele (precum Docker) sunt urmatoarea evolutie. Ele impart acelasi sistem de operare gazda dar ruleaza procese izolate. Sunt usoare, rapide la pornire si portabile.
11~
12Containerele au rezolvat problema portabilitatii dar au creat alta: cum sa gestionezi sute (sau mii) de containere intr-un mediu de productie? Cum sa te asiguri ca ruleaza mereu, pot comunica intre ele si pot scala in functie de incarcare?
13~
14Aici intervine **Kubernetes**.
15~
16## Ce este Kubernetes?
17~
18Kubernetes (adesea abreviat ca **K8s**) este o platforma open-source pentru orchestrarea containerelor. Pe scurt, automatizeaza implementarea, scalarea si gestionarea aplicatiilor containerizate. Creat de Google si acum intretinut de Cloud Native Computing Foundation (CNCF), Kubernetes a devenit instrumentul de referinta pentru oricine lucreaza cu microservicii la scara.
19~
20## Arhitectura unui cluster Kubernetes
21~
22Un mediu Kubernetes se numeste **cluster**. Un cluster este compus dintr-un set de masini, numite **noduri**, care ruleaza aplicatiile noastre. Arhitectura este impartita in doua parti principale: Planul de control si Nodurile Worker.
23~
24```mermaid
25graph TD
26    subgraph "Control Plane (Master)"
27        A["API Server"]
28        B["etcd"]
29        C["Scheduler"]
30        D["Controller Manager"]
31    end
32~
33    subgraph "Worker Node 1"
34        E["Kubelet"] --- F["Container Runtime"]
35        G["Kube-proxy"]
36        F --- H["Pod"]
37        F --- I["Pod"]
38    end
39~
40    subgraph "Worker Node 2"
41        J["Kubelet"] --- K["Container Runtime"]
42        L["Kube-proxy"]
43        K --- M["Pod"]
44    end
45~
46    A -- "Communicates with" --> E
47    A -- "Communicates with" --> J
48    User -- "kubectl" --> A
49    C -- "Assigns Pods to Nodes" --> E
50    D -- "Maintains state" --> A
51    A -- "Saves/Reads state" --> B
52```
53~
54### Planul de control
55~
56Planul de control este "creierul" clusterului. Ia decizii globale (precum planificarea) si detecteaza si raspunde la evenimentele clusterului. Componentele sale principale sunt:
57~
58-   **API Server (`kube-apiserver`)**: Este poarta de acces la cluster. Expune API-ul Kubernetes, utilizat de utilizatori (prin `kubectl`), componentele clusterului si instrumentele externe.
59-   **etcd**: O baza de date cheie-valoare consistenta si inalt disponibila. Stocheaza toate datele clusterului.
60-   **Scheduler (`kube-scheduler`)**: Asigneaza Pod-urile nou create unui Nod Worker disponibil.
61-   **Controller Manager (`kube-controller-manager`)**: Ruleaza controlere, care sunt bucle de control ce urmaresc starea clusterului si lucreaza pentru a o aduce la starea dorita.
62~
63### Nodul Worker
64~
65Nodurile Worker sunt masinile unde aplicatiile ruleaza efectiv. Fiecare nod contine:
66~
67-   **Kubelet**: Un agent care ruleaza pe fiecare nod. Se asigura ca containerele descrise in Pod-uri ruleaza si sunt sanatoase.
68-   **Kube-proxy**: Un proxy de retea care gestioneaza regulile de retea pe noduri.
69-   **Container Runtime**: Software-ul responsabil pentru rularea containerelor. Docker este cel mai faimos, dar Kubernetes suporta si alte runtime-uri precum `containerd` si `CRI-O`.
70~
71## Obiecte fundamentale Kubernetes
72~
73In Kubernetes, totul este reprezentat de **obiecte**. Iata cele mai importante:
74~
75### Pod
76~
77**Pod-ul** este cea mai mica unitate de executie in Kubernetes. Reprezinta unul sau mai multe containere care ruleaza impreuna pe acelasi nod, impartind resurse precum reteaua si stocarea.
78~
79### Deployment
80~
81Un **Deployment** este obiectul pe care il vei folosi cel mai des. Descrie starea dorita pentru un grup de Pod-uri identice.
82~
83```yaml
84# nginx-deployment.yaml
85apiVersion: apps/v1
86kind: Deployment
87metadata:
88  name: nginx-deployment
89spec:
90  replicas: 3
91  selector:
92    matchLabels:
93      app: nginx
94  template:
95    metadata:
96      labels:
97        app: nginx
98    spec:
99      containers:
100      - name: nginx
101        image: nginx:1.14.2
102        ports:
103        - containerPort: 80
104```
105~
106### Service
107~
108Pod-urile in Kubernetes sunt efemere. Un **Service** ofera un **punct de acces stabil** (o adresa IP virtuala si un nume DNS) pentru un grup de Pod-uri.
109~
110```mermaid
111graph TD
112    subgraph "Service (nginx-service)"
113        A["ClusterIP: 10.96.0.10"]
114    end
115~
116    subgraph "Pods"
117        B("Pod 1 - IP: 192.168.1.2")
118        C("Pod 2 - IP: 192.168.1.3")
119        D("Pod 3 - IP: 192.168.1.4")
120    end
121~
122    A -- "Selector: app=nginx" --> B
123    A -- "Selector: app=nginx" --> C
124    A -- "Selector: app=nginx" --> D
125~
126    Client -- "Request to nginx-service" --> A
127```
128~
129```yaml
130# nginx-service.yaml
131apiVersion: v1
132kind: Service
133metadata:
134  name: nginx-service
135spec:
136  selector:
137    app: nginx
138  ports:
139    - protocol: TCP
140      port: 80
141      targetPort: 80
142  type: ClusterIP # Default - expune serviciul doar in cadrul clusterului
143```
144~
145Exista diferite tipuri de Servicii:
146- `ClusterIP`: Expune serviciul pe un IP intern al clusterului (implicit).
147- `NodePort`: Expune serviciul pe un port static pe fiecare Nod Worker.
148- `LoadBalancer`: Creeaza un load balancer extern in furnizorul cloud si asigneaza un IP public serviciului.
149~
150### Ingress
151~
152Un **Ingress** actioneaza ca un "router inteligent" pentru traficul extern. Permite definirea regulilor de rutare bazate pe host sau cale.
153~
154```mermaid
155graph LR
156    User -- "mysite.com/api" --> Ingress
157    User -- "mysite.com/ui" --> Ingress
158~
159    subgraph "Cluster"
160        Ingress -- "/api" --> ServiceA("api-service")
161        Ingress -- "/ui" --> ServiceB("ui-service")
162~
163        ServiceA --> PodA1("API Pod 1")
164        ServiceA --> PodA2("API Pod 2")
165~
166        ServiceB --> PodB1("UI Pod 1")
167        ServiceB --> PodB2("UI Pod 2")
168    end
169```
170~
171### Alte obiecte utile
172~
173-   **Namespace**: Permite crearea de "clustere virtuale" in interiorul unui cluster fizic.
174-   **ConfigMap si Secret**: Pentru gestionarea datelor de configurare si secretelor decuplate de imaginea containerului.
175-   **StatefulSet**: Similar cu un Deployment, dar specific pentru aplicatii cu stare.
176-   **PersistentVolume (PV) si PersistentVolumeClaim (PVC)**: Pentru gestionarea stocarii persistente in cluster.
177~
178## Concluzie
179~
180Kubernetes este un instrument incredibil de puternic, dar curba sa de invatare poate fi abrupta. Ce sa faci acum?
181- **Experimenteaza local**: Instaleaza [Minikube](https://minikube.sigs.k8s.io/docs/start/) sau [Kind](https://kind.sigs.k8s.io/docs/user/quick-start/).
182- **Foloseste `kubectl`**: Familiarizeaza-te cu comanda `kubectl`.
183- **Exploreaza tutorialele oficiale**: [Documentatia Kubernetes](https://kubernetes.io/docs/tutorials/) este o resursa fantastica.
184~
185Orchestrarea containerelor este o competenta fundamentala in lumea cloud-native, iar stapanirea Kubernetes iti va deschide o lume de posibilitati. Distractie placuta!
186~