I nomi, legati al corso in cui li hai visti

L’insieme di control plane + nodi. Per te è “l’ambiente Kubernetes”. Su GKE è un oggetto che crei nella console.

I cervelli: API server, etcd, scheduler, controller. Di solito non eseguono i container delle app (taint NoSchedule sui nodi control-plane). Non è un vincolo assoluto: quel nodo si può rendere schedulabile, e allora ci girano anche i Pod.

Una macchina (VM) che esegue i Pod. Sopra ci sono kubelet, runtime e di solito kube-proxy.

Unità schedulata: 1+ container che condividono rete e, se serve, volumi. Vive poco. Non è un server eterno.

Il file in cui dichiari l’oggetto (kind: Deployment, spec: …). È la lettera che mandi all’API.

Quello che hai chiesto (“voglio 3 repliche”). I controller lavorano finché la realtà non gli somiglia.

Uno scomparto logico nel cluster. OpenShift lo irrigidisce nel Project, con quote e policy.

Nome e IP stabile davanti a un gruppo di Pod. I Pod cambiano, il Service no.

Ingress (Kubernetes/GKE) e Route (OpenShift) espongono HTTP dall’esterno verso i Service.

Il file con indirizzo dell’API, certificati e contesto. È il badge per entrare in reception.

Container Runtime Interface: il contratto tra kubelet e chi avvia i container (containerd, CRI-O).

Container Network Interface: plugin che dà un IP al Pod e collega i nodi.

Chi (utente o ServiceAccount) può fare quale verbo su quale risorsa. get/list/create su pods, ecc.

Modalità in cui Google gestisce anche i nodi. Nel general purpose, di solito paghi le risorse richieste dai Pod. Hardware dedicato o GPU è un altro conto.

Un controller su misura per un software (database, Kafka…). OpenShift ne fa un pilastro.

Come cresce il costo al crescere dell’input, ignorando costanti.

Funzione che mappa una chiave in un cassetto. Collisioni possibili.

Proprietà che vuoi vera all’inizio e alla fine di ogni passo.

Pezzo indicizzato e recuperabile di un documento.

Vettore che colloca un testo in uno spazio di vicinanza. Indice e query: stesso spazio compatibile.

Quanti risultati tiri fuori in una fase di retrieve. Dopo possono scendere con rerank e filtri.

Giro che smista callback quando I/O e timer sono pronti. Il JS sincrono pesante lo ferma; serve offloading esplicito.

Cosa Node sta eseguendo adesso, un frame sopra l’altro.

Dati a pezzi, non per forza tutti in memoria.

Forma dei dati in ingresso/uscita. Da validare al confine.

Cancello: la request passa o no.

Avvolge l’handler: metà prima (dopo il Guard, prima della Pipe), metà dopo il controller/service.

Cosa Nest sa istanziare e iniettare (spesso un service).

Pezzo di testo che il modello tratta come unità.

Budget di token di una chiamata. A seconda di modello/API: input, e spesso anche output.

Continuazione plausibile non fondata sui fatti che ti servono.

L’umano conferma o corregge prima dell’azione costosa.

Segnale se la decisione era giusta, per migliorare o almeno monitorare.

Chi è sveglio quando il modello sbaglia in produzione.

I sistemi copiano i confini delle persone che li fanno.

Il fattore che limita il flusso. Accelerare altrove non basta.

Sostituire a fette, non in un cut-over unico.

Identificatore stabile della riga. Consigliata; SQL non la esige su ogni tabella.

Combina tavoli su una condizione. Spesso sulle chiavi, non per forza.

Struttura di lato per trovare righe senza scansione piena. Spesso B-tree; non solo.

Contratto delle transazioni: tutto-o-niente, regole, isolamento, persistenza.

Quello che hai dichiarato. I controller cercano di renderlo vero.

Unità che lo scheduler piazza su un nodo. Sostituito = un Pod nuovo, non lo stesso con un altro vestito.

Kubernetes di Google: control plane gestito.

Perché esiste, cosa è fatto, cosa è fuori, chi sblocca.

Albero del lavoro. I figli coprono il padre senza buchi.

Quante cose sono aperte insieme. Troppe = niente finisce.

Software che partiziona una macchina fisica in macchine virtuali.

Il sistema operativo dentro la VM.

Autentica (Kerberos) e rilascia ticket. L’autorizzazione la applica la risorsa (token/ACL).

Numero del processo vivo. Muore il processo, il PID si libera.

Richiesta al kernel: apri file, manda pacchetto, alloca memoria.

Maniglia numerica di una risorsa aperta (file, socket, pipe…). Il percorso è solo uno dei modi per arrivarci.

Dare il minimo potere che serve a far funzionare la cosa.