Deploy Kubernetes su Digital Ocean: la mini guida utile

DigitalOcean Kubernetes (DOKS) è un servizio Kubernetes managed (link all’articolo Servizi Cloud Kubernetes) che consente di distribuire cluster Kubernetes senza le complessità della gestione del control plane e dell’infrastruttura. I cluster sono compatibili con le toolchain Kubernetes standard e si integrano in modo nativo con DigitalOcean Load Balancer e i volumi block storage.

Deploy Kubernetes su Digital Ocean step by step

Puoi creare un cluster Kubernetes di DigitalOcean in qualsiasi momento dal pannello di controllo di DigitalOcean aprendo il menu Create in alto a destra.

Tag alt =  Deploy Kubernetes

Nel menu Create , fai clic su Kubernetes per andare alla pagina Create a cluster. In questa pagina sceglierai una versione di Kubernetes, una regione del data center e una capacità del cluster per il tuo cluster.

Seleziona una versione di Kubernetes

L’ultima versione della patch per le tre versioni secondarie più recenti di Kubernetes è disponibile per la creazione di nuovi cluster. L’ultima versione stabile è selezionata per impostazione predefinita.

Scegli una regione del datacenter

Scegli la regione per il tuo cluster. Il control plane e i worker nodes del tuo cluster si troveranno nella stessa regione.

Se prevedi di utilizzare volumi block storage per l’archiviazione permanente dei dati, scegli una regione che supporta questo tipo di volumi. Se aggiungi un Load Balancer al tuo deployment, verrà automaticamente posizionato nella stessa regione del cluster.

Rete VPC

Nella sezione VPC Network, scegli una rete VPC per il cluster. Puoi sceglierne una che hai creato o utilizzare la rete predefinita per l’area del data center. 

VPC crea un’interfaccia di rete aggiuntiva a cui è possibile accedere solo da altre risorse all’interno della stessa rete VPC. Tutto ciò impedisce al traffico di essere instradato all’esterno del data center su Internet pubblico.

Scegli la capacità del cluster

Per creare un cluster, devi aggiungere un node pool con almeno un worker node. Specifica i seguenti campi per il node pool:

• Nome del node pool. Scegli un nome per il node pool dopo che l’hai creato. Devi sapere che i nodi all’interno di questo pool ereditano questo schema di denominazione quando vengono creati. Non solo, se si rinomina il node pool in un secondo momento, i nodi erediteranno il nuovo schema di denominazione solo quando vengono ricreati (quando si riciclano i nodi o si ridimensiona il node pool).

• Machine type (droplet). Avrai diversi piani da scegliere: Basic (CPU standard, CPU Intel Premium o CPU AMD Premium), General Purpose o Droplet ottimizzato per la CPU.

• Node plan. Scegli il piano specifico che desideri per i tuoi worker node. 

• Per sfruttare le diverse capacità delle risorse, puoi creare node pool aggiuntivi con il pulsante “Aggiungi node pool aggiuntivi” e assegnare pod ai node pool con i vincoli di pianificazione appropriati .

• Numero di nodi. Scegli quanti nodi includere nel node pool. Di default vengono già selezionati tre worker node proprio perché questo è il numero minimo per “garantire high availability”.

Nella parte inferiore di questa sezione, vedrai la tariffa mensile per il tuo cluster in base alle risorse che hai scelto. Quando crei il cluster, la fatturazione viene effettuata per ogni tipo di risorsa (ad es. worker node, block storage, load balancer) 

Aggiungi i tag

I cluster hanno automaticamente tre tag :

• k8s
• L’ID cluster specifico, come k8s:EXAMPLEc-3515-4a0c-91a3-2452eEXAMPLE
• Il tipo di risorsa, (ad es. k8s:worker)

È inoltre possibile aggiungere tag personalizzati a un cluster e ai relativi node pool nelle pagine Overview e Nodes. Eventuali tag personalizzati aggiunti ai nodi in un node pool (ad esempio, dalla pagina Droplet), vengono eliminati per mantenere la coerenza tra il node pool e i relativi worker node.

Scegli un nome

Per impostazione predefinita, i nomi dei cluster iniziano con k8s, seguiti dalla versione di Kubernetes, dalla regione del data center e dall’ID del cluster. È possibile personalizzare il nome del cluster, che verrà utilizzato anche nel tag.

Seleziona il progetto

Il nuovo cluster appartiene al tuo progetto predefinito. Puoi assegnare il cluster a un progetto diverso.

Puoi anche modificare il progetto dopo aver creato il cluster. Vai alla pagina Kubernetes nel pannello di controllo . Dal menu More del cluster, seleziona Move To in e seleziona il progetto in cui si desidera spostare il cluster.

Anche le risorse associate, come i load balancer e i volumi di archiviazione, si spostano quando si sposta il cluster in un progetto diverso.

Crea il cluster

Dopo aver inserito le altre impostazioni, creare il cluster facendo clic sul pulsante Create cluster  è semplicissimo. Il completamento della creazione del cluster può richiedere diversi minuti.

Una volta eseguito il provisioning del cluster, puoi utilizzare kubectl, il client per riga di comando ufficiale di Kubernetes, proprio per gestire il cluster.

In conclusione

Il setup di Kubernetes su Digital Ocean è molto semplice e viene esguito tramite l’interfaccia grafica del pannello amministrativo di Digital Ocean. Ti invitiamo a leggere la documentazione ufficiale Kubernetes e Digital Ocean per ulteriori approfondimenti

E’ possibile creare un cluster Kubernetes sia tramite l’interfaccia web di Azure, sia tramite command line.

Kubernetes Azure: tutto ciò che devi sapere

Vediamo come eseguire l’installazione di Kubernetes su MS Azure tramite riga di comando.

Preparare la shell è il primo step!

Sono disponibili due opzioni: una consiste nell’usare la shell interattiva di Azure, l’altra nell’installare gli strumenti della riga di comando di Azure in locale. Di seguito sono riportate le istruzioni per ciascuno.

1 – Shell interattiva di Azure

Il portale di Azure contiene una shell interattiva che puoi usare per comunicare con il tuo cluster Kubernetes. Per accedere a questa shell, vai su portal.azure.com loggati e fai clic sul pulsante in basso.

Tag alt = Kubernetes Azure

2 – Command line tools in locale

 Puoi accedere all’interfaccia della riga di comando di Azure tramite un pacchetto che puoi installare localmente.

A tale scopo, segui prima le istruzioni di installazione nella documentazione di Azure. Quindi esegui il seguente comando per connettere la tua CLI locale con il tuo account:

az login

Dovrai aprire un browser e seguire le istruzioni nel tuo terminale per accedere.

Attivare la subscription

Azure usa il concetto di subscription (abbonamenti) per gestire i costi. Puoi ottenere un elenco di subscription a cui il tuo account ha accesso eseguendo:

az account list –refresh –output table

Scegli la subscription che desideri utilizzare per creare il cluster e impostala come predefinita. Se hai un solo abbonamento puoi ignorare questo passaggio.

az account set –subscription <SUBSCRIPTION-NAME>

Creare un resource group

Azure usa il concetto di resource group per raggruppare le risorse correlate. Dobbiamo creare un resource group in una determinata posizione del data center. Creeremo risorse di calcolo all’interno di questo resource group.

az group create \

   –name=<RESOURCE-GROUP-NAME> \

   –location=centralus \

   –output table

Imposta un nome per il cluster

Nei passaggi seguenti eseguiremo i comandi che ti chiedono di inserire un nome di cluster. Ti consigliamo di utilizzare qualcosa di descrittivo e breve. Faremo riferimento a questo come <CLUSTER-NAME> per il resto di questa sezione.

Il passaggio successivo creerà alcuni file sul tuo filesystem, quindi prima crea una cartella in cui andranno questi file. Ti consigliamo di assegnargli lo stesso nome del tuo cluster:

mkdir <CLUSTER-NAME>

cd <CLUSTER-NAME>

Crea una chiave SSH

ssh-keygen -f ssh-key-<CLUSTER-NAME>

Ti verrà chiesto di aggiungere una password, che puoi lasciare vuota se lo desideri. A questo punto verrà creata una chiave pubblica denominata ssh-key-<CLUSTER-NAME>.pub e una chiave privata denominata ssh-key-<CLUSTER-NAME>. Assicurati che entrambi entrino nella cartella che abbiamo creato in precedenza e tienili entrambi al sicuro!

Crea un virtual network e un sub-network

Kubernetes non ha di default un controller che applica le risorse e le policy di rete. le risorse networkpolicy sono importanti in quanto definiscono il modo in cui i pod Kubernetes possono comunicare in modo sicuro tra loro e con l’esterno, ad esempio Internet.

Per abilitarlo in Azure, dobbiamo prima creare una rete virtuale con i criteri di rete di Azure abilitati.

az network vnet create \

   –resource-group <RESOURCE-GROUP-NAME> \

   –name <VNET-NAME> \

   –address-prefixes 10.0.0.0/8 \

   –subnet-name <SUBNET-NAME> \

   –subnet-prefix 10.240.0.0/16

Recupereremo ora gli application ID della rete virtuale e della subnet appena creati e li salveremo nelle variabili bash.

VNET_ID=$(az network vnet show \

   –resource-group <RESOURCE-GROUP-NAME> \

   –name <VNET-NAME> \

   –query id \

   –output tsv)

SUBNET_ID=$(az network vnet subnet show \

   –resource-group <RESOURCE-GROUP-NAME> \

   –vnet-name <VNET-NAME> \

   –name <SUBNET-NAME> \

   –query id \

   –output tsv)

Creeremo un’entità servizio di Azure Active Directory (Azure AD) da usare con il cluster e assegneremo il ruolo di collaboratore da usare con la rete virtuale. Assicurati che SERVICE-PRINCIPAL-NAME sia qualcosa di riconoscibile, ad esempio binderhub-sp.

SP_PASSWD=$(az ad sp create-for-rbac \

   –name <SERVICE-PRINCIPAL-NAME> \

   –role Contributor \

   –scopes $VNET_ID \

   –query password \

   –output tsv)

SP_ID=$(az ad sp show \

   –id http://<SERVICE-PRINCIPAL-NAME> \

   –query appId \

   –output tsv)

Crea il cluster Kubernetes

A questo punto, potresti pensare di effettuare il provisioning del tuo cluster Kubernetes. Il seguente comando creerà un cluster Kubernetes (link all’articolo Cos’è Kubernetes) all’interno del resource group che abbiamo creato in precedenza.

az aks create \

   –name <CLUSTER-NAME> \

   –resource-group <RESOURCE-GROUP-NAME> \

   –ssh-key-value ssh-key-<CLUSTER-NAME>.pub \

   –node-count 3 \

   –node-vm-size Standard_D2s_v3 \

   –service-principal $SP_ID \

   –client-secret $SP_PASSWD \

   –dns-service-ip 10.0.0.10 \

   –docker-bridge-address 172.17.0.1/16 \

   –network-plugin azure \

   –network-policy azure \

   –service-cidr 10.0.0.0/16 \

   –vnet-subnet-id $SUBNET_ID \

   –output table

Questo dovrebbe richiedere alcuni minuti e fornirti un cluster Kubernetes funzionante!

Installa kubectl

Se stai usando la CLI di Azure in locale, installa kubectl, uno strumento per accedere all’API Kubernetes dalla riga di comando:

az aks install-cli

Nota: kubectl è già installato in Azure Cloud Shell.

Ottieni le credenziali per kubectl

az aks get-credentials \

   –name <CLUSTER-NAME> \

   –resource-group <RESOURCE-GROUP-NAME> \

   –output table

Questo commando aggiornerà automaticamente il file di configurazione di Kubernetes.

Verifica che il cluster sia funzionante

kubectl get node

La risposta dovrebbe elencare tre nodi in esecuzione e le loro versioni Kubernetes! Ogni nodo dovrebbe avere lo stato di Ready. Tieni presente che questo potrebbe richiedere alcuni istanti.

In conclusione

Abbiamo visto come creare un cluster Kubernetes in pochi semplici passi. Ti consigliamo sempre di fare riferimento alla documentazione ufficiale Azure per ulteriori approfondimenti.

Vediamo come fare il setup di Kubernetes su un server cluster. L’esempio è applicato su
un cluster di macchine con CentOS7 ma può essere replicato su qualsiasi macchina basata
su Linux.

Set Up Kubernetes

Vediamo insieme tutti i passaggi relativi al set up di Kuberntes(link all’art cos’è Kubernetes) nel modo più dettagliato possibile.

Prerequisiti

Abbiamo bisogno di:

• più server con CentOS7 in esecuzione (1 master node e 1+ worker nodes)
• Un account utente su ogni macchina con privilegi di amministrazione
• Docker(link all’art Cos’è Docker) installato su ogni macchina

Configurare il repository Kubernetes

In primis dobbiamo sempre considerare che i pacchetti Kubernetes non sono disponibili tramite i repository CentOS 7 ufficiali. Questo passaggio pertanto deve essere eseguito sul master node e su ogni worker node. 

E’ dunque il seguente comando che deve essere eseguito per recuperare il repository dal quale successivamente recuperare l’installer per Kubernetes:

cat <<EOF > /etc/yum.repos.d/kubernetes.repo

Installazione di kubelet, kubeadm, e kubectl

Questi 3 pacchetti di base sono necessari per poter utilizzare Kubernetes. Installa i seguenti pacchetti su ogni nodo facendo così come vedi nell’esempio:

sudo yum install -y kubelet kubeadm kubectl

systemctl enable kubelet

systemctl start kubelet

Prima di eseguire il deploy di un cluster, assicurati di impostare gli hostname configurando il firewall e le impostazioni del kernel.

Impostare l’hostname di un node

Per dare un nome host univoco a ciascuno dei tuoi nodi, usa questo comando:

sudo hostnamectl set-hostname master-node

oppure

sudo hostnamectl set-hostname worker-node1

In questo esempio, il nodo master è ora denominato master-node, mentre un nodo di lavoro viene denominato worker-node1.

Adesso crea un un record DNS per risolvere il nome host per tutti i nodi:

192.168.1.10 master.example.com master-node

192.168.1.20 node1. example.com node1 worker-node

Configurare il firewall

I nodi, i container e i pod devono essere in grado di comunicare attraverso il cluster per svolgere le loro funzioni. Su CentOS di default è installato Firewalld. Aggiungi le seguenti porte immettendo i comandi elencati.

Sul Master Node pertanto esegui:

sudo firewall-cmd –permanent –add-port=6443/tcp

sudo firewall-cmd –permanent –add-port=2379-2380/tcp

sudo firewall-cmd –permanent –add-port=10250/tcp

sudo firewall-cmd –permanent –add-port=10251/tcp

sudo firewall-cmd –permanent –add-port=10252/tcp

sudo firewall-cmd –permanent –add-port=10255/tcp

sudo firewall-cmd –reload

Arrivato a questo punto esegui questi comandi su ogni worker node:

sudo firewall-cmd –permanent –add-port=10251/tcp

sudo firewall-cmd –permanent –add-port=10255/tcp

firewall-cmd –reload

Aggiorna le impostazioni Iptables

Imposta il valore di net.bridge.bridge-nf-call-iptables a “1” nel file di configurazione sysctl. Questo assicura che i pacchetti vengano correttamente processati dalle IP tables al momento del filtering e del port forwarding.

cat <<EOF > /etc/sysctl.d/k8s.conf

net.bridge.bridge-nf-call-ip6tables = 1

net.bridge.bridge-nf-call-iptables = 1

EOF

sysctl –system

Disabilita SELinux

I container devono accedere al filesystem host. SELinux deve essere impostato sulla modalità permissiva, che disabilita le sue funzioni di sicurezza.

Usa i seguenti comandi per disabilitare SELinux

sudo setenforce 0

sudo sed -i ‘s/^SELINUX=enforcing$/SELINUX=permissive/’ /etc/selinux/config

Disabilita SWAP

Infine, dobbiamo disabilitare SWAP per consentire a kubelet di funzionare correttamente:

sudo sed -i ‘/swap/d’ /etc/fstab

sudo swapoff -a

Crea un cluster con kubeadm

Inizializza il cluster con il seguente comando:

sudo kubeadm init –pod-network-cidr=10.244.0.0/16

Il completamento del processo potrebbe richiedere diversi minuti in base alla velocità della rete. Al termine di questo comando, viene visualizzato un messaggio di partecipazione a kubeadm. Prendi nota del record e usalo per unire i worker node al cluster in una fase successiva.

Gestisci il cluster come utente standard

Per utilizzare il cluster devi potervi accedere come utente standard. Esegui il seguente set di comandi:

mkdir -p $HOME/.kube

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

sudo chown $(id -u):$(id -g) $HOME/.kube/config

Imposta Pod Network

Il pod network consente ai nodi all’interno del cluster di comunicare tra di loro. Sono disponibili diverse opzioni di rete Kubernetes. Usa il seguente comando per installare il componente aggiuntivo flannel pod network:

sudo kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Se decidi di utilizzare flannel, modifica le regole del firewall per consentire il traffico per la porta predefinita 8285 di flannel.

Verifica lo stato del kluster

Verifica lo stato dei nodi eseguendo il seguente comando sul server master:

sudo kubectl get nodes

Una volta installata una rete pod, puoi confermare che funzioni controllando che il pod CoreDNS sia in esecuzione digitando:

sudo kubectl get pods –all-namespaces

Aggiungi un worker node al cluster

Puoi utilizzare il comando kubeadm join su ogni worker node per connetterlo al cluster.

kubeadm join –discovery-token cfgrty.1234567890jyrfgd –discovery-token-ca-cert-hash sha256:1234..cdef 1.2.3.4:6443

Sostituisci i codici con quelli del tuo server principale. Ripeti questa azione per ogni worker node sul tuo cluster.

In conclusione

Hai installato correttamente Kubernetes su CentOS e ora puoi gestire i cluster su più server. 

Questo tutorial di Kubernetes fornisce un buon punto di partenza per esplorare le numerose opzioni che questa piattaforma ha da offrire. Usa Kubernetes per l’autoscaling dei tuoi container in modo da dedicare meno tempo alla microgestione di ognuno di essi!

Installazione di Kubernetes: mini guida dedicata all’installazione di Kubernetes in locale

Installare e dunque avviare Kubernetes in locale è il modo migliore per vedere e comprendere tutti i componenti di Kubernetes e come si integrano fra di loro.

Kubernetes funziona quasi ovunque, su diverse versioni di Linux e grazie a diversi servizi cloud (link articolo “Servizi Cloud Kubernetes”), la compatibilità di questo tool con i sistemi operativi utilizzati in tutto il mondo rappresenta uno dei veri punti di forza di questo strumento.

Se date un’occhiata  al sito ufficiale di Kubernetes troverete una pagina della documentazione che riepiloga lo stato delle numerose combinazioni di distribuzione del sistema oltre a tutta una serie di guide introduttive che vi potranno dare alcuni spunti notevoli per una corretta installazione di Kubernetes in locale.

Detto questo, Kubernetes può essere distribuito in modalità autonoma, l’unica vera necessità è quella di avere Linux con Docker installato sulla propria macchina o su una virtual machine. 

Prima di entrare nel dettaglio diamo una ripassata all’architettura di Kubernetes, vi tornerà utile nel prosieguo della lettura: 

• Il master è il “piano di controllo” di Kubernetes e ha una serie di componenti a livello di cluster, incluso un server API che gli strumenti (ad esempio kubectl ) utilizzano per interagire con il cluster.
• Ogni nodo ha un servizio kubelet che riceve ordini dal master e un runtime del container (incluso ma non limitato a Docker) con cui si interfaccia per gestire le istanze del container. Vediamolo in azione e descriviamo ulteriormente questi componenti mentre li configuriamo.

Installazione Kubernetes in locale

Come descritto nella guida introduttiva, ci sono solo tre passaggi per ottenere un cluster autonomo attivo e funzionante, li vediamo insieme

Fase uno: eseguire etcd

docker run -d \

    –net=host \

    gcr.io/google_containers/etcd:2.0.9 \

    /usr/local/bin/etcd \

        –addr=127.0.0.1:4001 \

        –bind-addr=0.0.0.0:4001 \

        –data-dir=/var/etcd/data

Kubernetes utilizza etcd per archiviare in modo affidabile lo stato principale e la configurazione. I vari componenti master “osservano” questi dati e agiscono di conseguenza, ad esempio avviando un nuovo contenitore per mantenere un numero desiderato di repliche.

Fase due: eseguire il Master

docker run -d \

    –net=host \

    -v /var/run/docker.sock:/var/run/docker.sock \

    jetstack/hyperkube:v0.20.1 \

    /hyperkube kubelet \

        –api_servers=http://localhost:8080 \

        –v=2 \

        –address=0.0.0.0 \

        –enable_server \

        –hostname_override=127.0.0.1 \

        –config=/etc/kubernetes/manifests

Questo passaggio esegue un contenitore kubelet, che in questa distribuzione locale esegue a sua volta i componenti a livello di cluster che formano il “piano di controllo” principale di Kubernetes.

• Server API : fornisce l’API Kubernetes RESTful per gestire la configurazione del cluster, supportata dal datastore etcd.
• Scheduler : posiziona i pod sui nodi in base a regole (ad es. etichette). In questa fase, lo scheduler è semplice ma, come la maggior parte dei componenti in Kubernetes, è configurabile.
• Controller Manager : gestisce tutte le funzioni a livello di cluster, inclusa la creazione/aggiornamento degli endpoint, il rilevamento dei nodi, la gestione e il monitoraggio e la gestione dei pod.

Passaggio tre: eseguire il proxy di servizio

docker run -d \

   –net=host \

   –privileged \

   jetstack/hyperkube:v0.20.1 \

   /hyperkube proxy \

        –master=http://127.0.0.1:8080 \

        –v=2

Il proxy ( kube-proxy ) viene eseguito su ciascun nodo e fornisce un semplice proxy di rete e capacità di bilanciamento del carico. Questo proxy consente di esporre i servizi con un indirizzo di rete e un nome stabili.

A questo punto dovremmo avere un cluster Kubernetes eseguibile localmente. Per essere sicuri che tutto sia a posto, potete usare Docker ps per controllare le istanze del contenitore in esecuzione; dovrebbe essere simile a questo che vedete nell’immagine qui sotto (diverse colonne sono state omesse per brevità):

IMMAGINE	COMANDO
jetstack/hyperkube:v0.20.1	/hyperkube proxy
jetstack/hyperkube:v0.20.1	/hyperkube scheduler
jetstack/hyperkube:v0.20.1	/hyperkube apiserver
jetstack/hyperkube:v0.20.1	/hyperkube controller
gcr.io/google_containers/pause:0.8.0	/pause
jetstack/hyperkube:v0.20.1	/hyperkube kubelet
gcr.io/google_containers/etcd:2.0.9	/usr/local/bin/etcd

tag alt = installazione Kubernetes

Per interagire con il cluster dobbiamo utilizzare lo strumento CLI di kubectl. Può essere scaricato  pre-costruito direttamente da Google (nota 0.20.1 è l’ultima versione al momento della scrittura).

wget https://storage.googleapis.com/kubernetes-release/release/v0.20.1/bin/linux/amd64/kubectl

chmod u+x kubetctl

sudo  mv kubectl /usr/local/bin/

Il modo più rapido per avviare un container nel cluster consiste nell’usare il comando kubectl run. Quindi, ad esempio, per avviare un container Nginx, potrete utilizzare il comando e fare riferimento al nome dell’immagine del contenitore.

kubectl run web –image=nginx

Sebbene ciò sia conveniente e adatto per la sperimentazione, le risorse come i pod vengono generalmente create utilizzando artefatti di configurazione che possono avere dei vantaggi dal fatto che possano essere versionati con GIT, quindi ad esempio facilitando i rollback.

Se si usa YAML (o JSON), viene dichiarato un pod e il suo stato desiderato; è compito poi di Kubernetes garantire che questo pod esista sempre in base a questa specifica fino a quando non viene eliminato.

Ecco un semplice esempio di configurazione di un pod per quel pod nginx (file nginx-pod.yml).

apiVersion: v1

kind: Pod

metadata:

 name: nginx

 labels:

   app: web

spec:

 containers:

   – name: nginx

     image: nginx

Questo esegue la stessa immagine del  container (nginx) di cui sopra, ma in questo caso la configurazione della risorsa specifica alcuni metadati aggiuntivi, ad esempio un’etichetta (coppia chiave/valore) che assegna a questo pod un’etichetta del tipo “app” di “web”. 

kubectl create -f nginx-pod.yml

Kubernetes, in background, istruirà un nodo per estrarre l’immagine del contenitore avviando a sua volta il medesimo container.

A questo punto userete di nuovo kubectl pochi istanti dopo e dovresti essere in grado di vedere il pod nginx in esecuzione.

$ kubectl get pods

POD    IP              CONTAINER(S)  IMAGE(S)   HOST                     LABELS     STATUS    CREATED

web1   172.17.0.1      nginx         nginx      127.0.0.1/127.0.0.1      app=web  Running   About a minute web1

Come richiesto, un contenitore Nginx è ora in esecuzione in un pod (web1-qtlc1 in questo caso) e gli è stato inoltre assegnato un indirizzo IP. In Kubernetes, a ogni pod viene assegnato un indirizzo IP da una rete interna e questo significa che i pod possono comunicare tra loro, peraltro, in questo caso abbiamo distribuito Kubernetes con Docker utilizzando la rete host (–net=host) e questi indirizzi IP saranno accessibili localmente.

Kubernetes Cloud: vediamo da vicino Amazon Elastic Kubernetes Service (EKS)  Google Kubernetes Engine (GKE) e Servizio Azure Kubernetes (AKS)

I Servizi Cloud Per Kubernetes piùI Servizi Cloud Per Kubernetes più popolari sono senza alcun dubbio Amazon Elastic Kubernetes Service (EKS) Google Kubernetes Engine (GKE) Azure Kubernetes Service (AKS)

Questi servizi sono così detti “managed”. Che cosa si intende per “managed”.

In sostanza chi carica i file di configurazione di un server su Kubernetes, si ritrova a beneficiare del provisioning di tutta l’architettura lato server che viene fatta da kubernetes stesso grazie al lavoro svolto da questi providers. 

Li vediamo da vicino e capiamo quanto possono essere utili per chi ha intenzione di utilizzare Kubernetes al massimo livello.

Amazon Elastic Kubernetes Service (EKS)

Amazon Elastic Kubernetes Service è un servizio relativamente nuovo; rilasciato nel 2018, negli ultimi anni è stato protagonista di una crescita costante, voluminosa a tratti inarrestabile.

Con EKS è possibile avviare, eseguire e ridimensionare le applicazioni Kubernetes nel cloud AWS o in locale. EKS si basa su Kubernetes Upstream, questo servizio è infatti disponibile in più AWS Regions, ovverosia data center sparsi in giro per il mondo.

EKS include alcune opzioni di sicurezza e crittografia integrate, oltre ad automatizzare le attività di gestione chiave di Kubernetes come l’applicazione di patch, il provisioning dei nodi e i vari aggiornamenti come l’aggiornamento automatico e l’integrazione con CloudWatch per la registrazione, CloudTrail per il controllo e  IAM per le autorizzazioni di accesso. Inoltre per massimizzare le funzionalità dei suoi utenti, AWS contribuisce anche al codebase K8s open source.

Più recentemente AWS ha anche introdotto una nuova distribuzione K8s open source, si chiama EKS Distro, ed è una nuova opzione di distribuzione per Amazon EKS che ti consente di creare e gestire cluster Kubernetes sulla tua infrastruttura, includendo anche le macchine virtuali.

Google Kubernetes Engine (GKE)

Google Kubernetes Engine è il primo servizio cloud Kubernetes “managed” che ha saputo imporsi sul mercato. Stiamo parlando di un ambiente gestito per la distribuzione e la gestione di applicazioni containerizzate in un’infrastruttura Google sicura e flessibile.

GKE è considerata al giorno d’oggi una delle piattaforme Kubernetes più avanzate disponibili sul mercato. Progettato inizialmente per l’utilizzo su Google Cloud, può essere distribuito indistintamente in ambienti ibridi e in locale. GKE ha oltremodo semplificato la creazione di cluster: non a caso il tool offre alcune funzionalità avanzate di gestione dei cluster, tra cui il bilanciamento del carico, la scalabilità automatica, alcuni aggiornamenti automatici come la riparazione automatica del server, la registrazione e il monitoraggio.ng. 

Azure Kubernetes Service (AKS)

AKS di Microsoft sta pian piano diventando l’applicativo più utilizzato dagli utenti Kubernetes. Come con GKE e EKS, AKS è in grado di offrire ai propri utenti un ambiente K8s upstream gestito con aggiornamenti automatici con tanto di monitoraggio del cluster per semplificare la distribuzione e la gestione delle operazioni di Kubernetes. AKS offre diversi modalità per eseguire il provisioning di un cluster: console Web, riga di comando, Azure resource manager, Terraform e tanto altro ancora.

Dovete sapere che Il servizio Azure Kubernetes (in precedenza conosciuto come ACS – Azure Container Service ) è nato come piattaforma indipendente dall’orchester che supporta Kubernetes. E’ infatti sul finire del 2017 che Microsoft ha iniziato ad offrire servizi di gestione Kubernetes e, di conseguenza, ha deciso di deprecare ACS continuando ad offrire il proprio “affiancamento” a Kubernetes grazie a AKS.

Come funziona Kubernetes: mini guida per capire il funzionamento di uno dei tools più importanti per un developer oggi

Come funziona Kubernetes? Lo vediamo in questa mini guida tenendo sempre in considerazione che Kubernetes è un tool di grande rilevanza per un developer che vuole crescere e che realmente crede nella sua professione.

Iniziamo con il definire che cos’è Kubernetes (Cos’è Kubernetes), proprio perché stiamo parlando di una piattaforma di orchestrazione per container open source, progettata per l’esecuzione di applicazioni e servizi distribuiti su larga scala.

Ok, detto questo, che vuol dire poco e niente, vediamo come funziona Kubernetes e quali sono le funzionalità principali di questo strumento Devops che più di ogni altro oggi completa in maniera significativa le skills di un developer.

(altro…)

Docker vs Kubernetes: vediamo in cosa differiscono e perché a volte si tende a far confusione

Spesso sentiamo chiedere in giro se è meglio usare Docker o Kubernetes, come se si dovesse scegliere l’uno o l’altro. Ma è come paragonare mele e torte di mele. Se te lo sei chiesto anche tu, non ti preoccupare: è un fraintendimento molto comune.

(altro…)