Introduzione à l'Autorizazione Kubernetes di Hashicorp Consul

Hè propiu, dopu a liberazione Hashicorp Consul 1.5.0 à l'iniziu di maghju 2019, in Consul pudete auturizà applicazioni è servizii in esecuzione in Kubernetes nativamente.

In questu tutoriale creeremu passu per passu POC (Prova di cuncettu, PoC) chì dimustranu sta nova funzione Vi aspetta di avè una cunniscenza basica di Kubernetes è Hashicorp's Consul Mentre pudete aduprà qualsiasi piattaforma di nuvola o ambiente in u situ, in questu tutoriale useremu a piattaforma Cloud di Google.

riassuntu

Se andemu à Cunsultà a documentazione nantu à u so metudu d'autorizazione, Averemu una rapida visione di u so scopu è u casu d'usu, è ancu di qualchi dettagli tecnichi è una visione generale di a logica. Vi cunsigliu assai di leghje almenu una volta prima di prucede, postu chì avà spiegheraghju è masticaraghju tuttu.

Diagramma 1: Panoramica ufficiale di u metudu d'autorizazione Consul

Fighjemu in documentazione per un metudu specificu d'autorizazione Kubernetes.

Di sicuru, ci hè infurmazione utile, ma ùn ci hè micca una guida nantu à cumu aduprà veramente tuttu. Allora, cum'è ogni persona sana, scuzzulate l'Internet per guidà. È tandu... Avete fiascatu. Si passa. Fixemu questu.

Prima di passà à creà u nostru POC, vultemu à a visione generale di i metudi d'autorizazione di Consul (Diagramma 1) è affinà in u cuntestu di Kubernetes.

architettura

In questu tutoriale, creeremu un servitore Consul in una macchina separata chì cumunicà cù un cluster Kubernetes cù u cliente Consul installatu. Avemu da creà a nostra applicazione manichino in u pod è aduprà u nostru metudu d'autorizazione cunfigurata per leghje da u nostru magazzinu di chjave / valore di Consul.

U diagramma sottu detta l'architettura chì creamu in stu tutoriale, è ancu a logica daretu à u metudu d'autorizazione, chì serà spiegatu dopu.

Diagramma 2: Panoramica di u Metudu di Autorizazione Kubernetes

Una nota rapida: u servitore Consul ùn hà micca bisognu di campà fora di u cluster Kubernetes per questu travagliu. Ma iè, pò fà cusì è cusì.

Allora, pigliate u diagramma generale di u Consul (Diagramma 1) è applicà Kubernetes à questu, avemu u schema sopra (Diagramma 2), è a logica quì hè a siguenti:

1. Ogni pod averà un contu di serviziu attaccatu à ellu chì cuntene un token JWT generatu è cunnisciutu da Kubernetes. Stu token hè ancu inseritu in u pod per automaticamente.
2. A nostra applicazione o serviziu in u pod inizia un cumandamentu di login à u nostru cliente Consul. A dumanda di login includerà ancu u nostru token è nome creatu apposta metudu d'autorizazione (tipu Kubernetes). Stu passu #2 currisponde à u passu 1 di u schema Consul (Scheme 1).
3. U nostru Cliente Consul trasmetterà sta dumanda à u nostru servitore Consul.
4. MAGIA ! Questu hè induve u servitore Consul verifica l'autenticità di a dumanda, recullà infurmazioni nantu à l'identità di a dumanda è paraguna cù qualsiasi regule predefinite assuciate. Quì sottu hè un altru schema per illustrà questu. Stu passu currisponde à i passi 3, 4 è 5 di u schema generale di Consul (Diagramma 1).
5. U nostru servitore Consul genera un token Consul cù permessi secondu e nostre regule di metudu d'autorizazione specificate (chì avemu definitu) in quantu à l'identità di u richiedente. Allora rinviarà quellu token. Questu currisponde à u passu 6 di u schema Consul (Diagramma 1).
6. U nostru Cliente Consul trasmette u token à l'applicazione o serviziu chì richiede.

A nostra applicazione o serviziu pò avà aduprà stu token Consul per cumunicà cù i nostri dati Consul, cum'è determinatu da i privilegi di u token.

A magia hè revelata!

Per quelli di voi chì ùn sò micca felici cù solu un cunigliu fora di un cappellu è vulete sapè cumu funziona ... lasciami "mostravi quantu prufonda tana di cunigliu».

Comu diciatu prima, u nostru passu "magicu" (Figura 2: Step 4) hè induve u servitore Consul autentifica a dumanda, raccoglie infurmazioni nantu à a dumanda, è paraguna cù qualsiasi regule predefinite assuciate. Stu passu currisponde à i passi 3, 4 è 5 di u schema generale di Consul (Diagramma 1). Quì sottu hè un diagramma (Diagramma 3), u scopu di quale hè di mustrà chjaramente ciò chì succede in realtà sottu à u cappucciu un metudu specificu d'autorizazione Kubernetes.

Diagramma 3: A magia hè revelata!

1. Cum'è un puntu di partenza, u nostru Cliente Consul trasmette a dumanda di login à u nostru servitore Consul cù u token di u contu Kubernetes è u nome d'istanza specificu di u metudu d'autorizazione chì hè statu creatu prima. Stu passu currisponde à u passu 3 in a spiegazione di u circuitu precedente.
2. Avà u servitore Consul (o capu) hà bisognu di verificà l'autenticità di u token ricevutu. Dunque, cunsultarà u cluster Kubernetes (via u cliente Consul) è, cù i permessi appropritati, scupreremu se u token hè genuinu è à quale appartene.
3. A dumanda validata hè tornata à u capu Consul, è u servitore Consul cerca l'istanza di u metudu d'autorizazione cù u nome specificatu da a dumanda di login (è u tipu Kubernetes).
4. U capu di cunsul identifica l'istanza di u metudu d'autorizazione specificata (se trova) è leghje l'inseme di reguli di ubligatoriu chì sò attaccati à questu. Allora leghje queste regule è li compara cù l'attributi d'identità verificati.
5. TA-dah! Passemu à u passu 5 in a spiegazione di u circuitu precedente.

Eseguite Consul-server in una macchina virtuale regulare

Da avà, daraghju soprattuttu struzzioni nantu à cumu creà stu POC, spessu in punti di bullet, senza spiegazioni cumplete di frase. Inoltre, cum'è nutatu prima, aduprà GCP per creà tutta l'infrastruttura, ma pudete creà a stessa infrastruttura in ogni altru locu.

• Cumincià a macchina virtuale (istanza / servitore).

• Crea una regula per u firewall (gruppu di sicurità in AWS):
• Mi piace à assignà u listessu nome di macchina à a regula è à l'etichetta di a rete, in questu casu "skywiz-consul-server-poc".
• Truvate l'indirizzu IP di u vostru urdinatore locale è aghjunghje à a lista di l'indirizzi IP fonte per pudè accede à l'interfaccia d'utilizatore (UI).
• Apertura u portu 8500 per UI. Cliccate Crea. Cambiaremu dinò stu firewall prestu [ссылка].
• Aghjunghjite una regula di firewall à l'istanza. Torna à u dashboard VM in Consul Server è aghjunghje "skywiz-consul-server-poc" à u campu di tag di rete. Cliccate Salvà.

• Installa Consul in una macchina virtuale, verificate quì. Ricurdativi chì avete bisognu di a versione Consul ≥ 1.5 [link]
• Criemu un unicu node Consul - a cunfigurazione hè a siguenti.

groupadd --system consul
useradd -s /sbin/nologin --system -g consul consul
mkdir -p /var/lib/consul
chown -R consul:consul /var/lib/consul
chmod -R 775 /var/lib/consul
mkdir /etc/consul.d
chown -R consul:consul /etc/consul.d

• Per una guida più dettagliata nantu à l'installazione di Consul è a creazione di un cluster di 3 nodi, vede ccà.
• Crea un schedariu /etc/consul.d/agent.json cum'è seguente [ссылка]:

### /etc/consul.d/agent.json
{
 "acl" : {
 "enabled": true,
 "default_policy": "deny",
 "enable_token_persistence": true
 }
}

• Avviate u nostru servitore Consul:

consul agent 
-server 
-ui 
-client 0.0.0.0 
-data-dir=/var/lib/consul 
-bootstrap-expect=1 
-config-dir=/etc/consul.d

• Duvete vede una mansa di output è finisce cù "... aghjurnamentu bluccatu da ACLs".
• Truvate l'indirizzu IP esternu di u servitore Consul è apre un navigatore cù questu indirizzu IP in u portu 8500. Assicuratevi chì l'UI apre.
• Pruvate aghjunghje una coppia chjave / valore. Ci deve esse un sbagliu. Questu hè perchè avemu caricatu u servitore Consul cun ACL è disattivatu tutte e regule.
• Riturnà à a vostra cunchiglia nantu à u servitore Consul è cuminciate u prucessu in u sfondate o un altru modu per fà u funziunamentu è entre in u seguente:

consul acl bootstrap

• Truvate u valore "SecretID" è torna à l'UI. In a tabulazione ACL, inserite l'ID secretu di u token chì avete appena copiatu. Copia SecretID in un altru locu, avemu bisognu dopu.
• Avà aghjunghje una coppia chjave / valore. Per questu POC, aghjunghje i seguenti: chjave: "custom-ns/test_key", valore: "Sò in u cartulare custom-ns!"

Lanciazione di un cluster Kubernetes per a nostra applicazione cù u cliente Consul cum'è Daemonset

• Crea un cluster K8s (Kubernetes). Creemu in a stessa zona cum'è u servitore per un accessu più veloce, è cusì pudemu usà a stessa subnet per cunnette facilmente cù l'indirizzi IP interni. Chiameremu "skywiz-app-with-consul-client-poc".

• Cum'è una nota laterale, quì hè un bonu tutoriale chì aghju scontru mentre creanu un cluster POC Consul cù Consul Connect.
• Useremu ancu u graficu di u timone di Hashicorp cù un schedariu di valori allargati.
• Installa è cunfigurà Helm. Passi di cunfigurazione:

kubectl create serviceaccount tiller --namespace kube-system
kubectl create clusterrolebinding tiller-admin-binding 
   --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
./helm init --service-account=tiller
./helm update

• carta di timone: https://www.consul.io/docs/platform/k8s/helm.html
• Aduprate u seguente file di valore (nota chì aghju disattivatu a maiò parte):

### poc-helm-consul-values.yaml
global:
 enabled: false
 image: "consul:latest"
# Expose the Consul UI through this LoadBalancer
ui:
 enabled: false
# Allow Consul to inject the Connect proxy into Kubernetes containers
connectInject:
 enabled: false
# Configure a Consul client on Kubernetes nodes. GRPC listener is required for Connect.
client:
 enabled: true
 join: ["<PRIVATE_IP_CONSUL_SERVER>"]
 extraConfig: |
{
  "acl" : {
 "enabled": true,   
 "default_policy": "deny",   
 "enable_token_persistence": true 
  }
}
# Minimal Consul configuration. Not suitable for production.
server:
 enabled: false
# Sync Kubernetes and Consul services
syncCatalog:
 enabled: false

• Applicà a carta di timone:

./helm install -f poc-helm-consul-values.yaml ./consul-helm - name skywiz-app-with-consul-client-poc

• Quandu prova di curriri, avarà bisognu di permessi per u servitore di u Consul, per quessa, aghjunghje.
• Nota u "Pod Address Range" situatu nantu à u cluster dashboard è riferite à a nostra regula di firewall "skywiz-consul-server-poc".
• Aghjunghjite l'indirizzu per u pod à a lista di l'indirizzi IP è i porti aperti 8301 è 8300.

• Andate à u Consul UI è dopu uni pochi di minuti vi vede u nostru cluster apparisce in a tabulazione di i nodi.

Configurazione di un metudu d'autorizazione integrendu Consul cù Kubernetes

• Ritorna à a cunchiglia di u servitore Consul è esporta u token chì avete salvatu prima:

export CONSUL_HTTP_TOKEN=<SecretID>

• Averemu bisognu di infurmazioni da u nostru cluster Kubernetes per creà una istanza di u metudu di auth:
• kubernetes-host

kubectl get endpoints | grep kubernetes

• kubernetes-service-account-jwt

kubectl get sa <helm_deployment_name>-consul-client -o yaml | grep "- name:"
kubectl get secret <secret_name_from_prev_command> -o yaml | grep token:

• U token hè codificatu in base64, cusì decifrallu cù u vostru strumentu preferitu [ссылка]
• kubernetes-ca-cert

kubectl get secret <secret_name_from_prev_command> -o yaml | grep ca.crt:

• Pigliate u certificatu "ca.crt" (dopu à a decodificazione base64) è scrivite in u schedariu "ca.crt".
• Avà istanziate u metudu di auth, rimpiazzà i marcatori cù i valori chì avete appena ricevutu.

consul acl auth-method create 
-type "kubernetes" 
-name "auth-method-skywiz-consul-poc" 
-description "This is an auth method using kubernetes for the cluster skywiz-app-with-consul-client-poc" 
-kubernetes-host "<k8s_endpoint_retrieved earlier>" 
[email protected] 
-kubernetes-service-account-
jwt="<decoded_token_retrieved_earlier>"

• Dopu avemu bisognu di creà una regula è aghjunghje à u novu rolu. Per questa parte pudete aduprà Consul UI, ma avemu aduprà a linea di cummanda.
• Scrivite una regula

### kv-custom-ns-policy.hcl
key_prefix "custom-ns/" {
 policy = "write"
}

• Applica a regula

consul acl policy create 
-name kv-custom-ns-policy 
-description "This is an example policy for kv at custom-ns/" 
-rules @kv-custom-ns-policy.hcl

• Truvate l'ID di a regula chì avete appena creatu da a pruduzzioni.
• Crea un rolu cù una nova regula.

consul acl role create 
-name "custom-ns-role" 
-description "This is an example role for custom-ns namespace" 
-policy-id <policy_id>

• Avà assuciaremu u nostru novu rolu cù l'istanza di u metudu auth. Nota chì a bandiera "selettore" determina se a nostra dumanda di login riceverà stu rolu. Verificate quì per altre opzioni di selezzione: https://www.consul.io/docs/acl/auth-methods/kubernetes.html#trusted-identity-attributes

consul acl binding-rule create 
-method=auth-method-skywiz-consul-poc 
-bind-type=role 
-bind-name='custom-ns-role' 
-selector='serviceaccount.namespace=="custom-ns"'

Infine cunfigurazioni

I diritti di accessu

• Crea diritti d'accessu. Avemu bisognu à dà u permessu di Consul per verificà è identificà l'identità di u token di u contu di serviziu K8s.
• Scrivite i seguenti à u schedariu [link]:

###skywiz-poc-consul-server_rbac.yaml
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
 name: review-tokens
 namespace: default
subjects:
- kind: ServiceAccount
 name: skywiz-app-with-consul-client-poc-consul-client
 namespace: default
roleRef:
 kind: ClusterRole
 name: system:auth-delegator
 apiGroup: rbac.authorization.k8s.io
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
 name: service-account-getter
 namespace: default
rules:
- apiGroups: [""]
 resources: ["serviceaccounts"]
 verbs: ["get"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
 name: get-service-accounts
 namespace: default
subjects:
- kind: ServiceAccount
 name: skywiz-app-with-consul-client-poc-consul-client
 namespace: default
roleRef:
 kind: ClusterRole
 name: service-account-getter
 apiGroup: rbac.authorization.k8s.io

• Creemu diritti d'accessu

kubectl create -f skywiz-poc-consul-server_rbac.yaml

Cunnessione à u Cliente Consul

• Comu nutatu ccàCi hè parechje opzioni per cunnette à daemonset, ma andemu à a seguente suluzione simplice:
• Applica u seguente file [ссылка].

### poc-consul-client-ds-svc.yaml
apiVersion: v1
kind: Service
metadata:
 name: consul-ds-client
spec:
 selector:
   app: consul
   chart: consul-helm
   component: client
   hasDNS: "true"
   release: skywiz-app-with-consul-client-poc
 ports:
 - protocol: TCP
   port: 80
   targetPort: 8500

• Allora aduprate u seguitu cumandamentu integratu per creà un configmap [ссылка]. Per piacè nutate chì avemu riferitu à u nome di u nostru serviziu, rimpiazzà si ne necessariu.

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
 labels:
   addonmanager.kubernetes.io/mode: EnsureExists
 name: kube-dns
 namespace: kube-system
data:
 stubDomains: |
   {"consul": ["$(kubectl get svc consul-ds-client -o jsonpath='{.spec.clusterIP}')"]}
EOF

Pruvate u metudu di auth

Avà vedemu a magia in azione!

• Crea parechje più cartulare chjave cù a listessa chjave di u livellu superiore (ie. /sample_key) è un valore di a vostra scelta. Crea pulitiche è roles adatti per novi percorsi chjave. Faremu i ligami dopu.

Test di u spaziu di nomi persunalizati:

• Creemu u nostru spaziu di nomi:

kubectl create namespace custom-ns

• Creemu un pod in u nostru novu spaziu di nomi. Scrivite a cunfigurazione per u pod.

###poc-ubuntu-custom-ns.yaml
apiVersion: v1
kind: Pod
metadata:
 name: poc-ubuntu-custom-ns
 namespace: custom-ns
spec:
 containers:
 - name: poc-ubuntu-custom-ns
   image: ubuntu
   command: ["/bin/bash", "-ec", "sleep infinity"]
 restartPolicy: Never

• Crea sottu:

kubectl create -f poc-ubuntu-custom-ns.yaml

• Quandu u cuntinuu hè in esecuzione, andate quì è installate curl.

kubectl exec poc-ubuntu-custom-ns -n custom-ns -it /bin/bash
apt-get update && apt-get install curl -y

• Avà manderemu una dumanda di login à Cunsul usendu u metudu d'autorizazione chì avemu creatu prima [ссылка].
• Per vede u token inseritu da u vostru contu di serviziu:

cat /run/secrets/kubernetes.io/serviceaccount/token

• Scrivite u seguente à un schedariu in u containeru:

### payload.json
{
 "AuthMethod": "auth-method-test",
 "BearerToken": "<jwt_token>"
}

• Accedi!

curl 
--request POST 
--data @payload.json 
consul-ds-client.default.svc.cluster.local/v1/acl/login

• Per compie i passi sopra in una sola linea (poi chì eseguiremu parechje teste), pudete fà i seguenti:

echo "{ 
"AuthMethod": "auth-method-skywiz-consul-poc", 
"BearerToken": "$(cat /run/secrets/kubernetes.io/serviceaccount/token)" 
}" 
| curl 
--request POST 
--data @- 
consul-ds-client.default.svc.cluster.local/v1/acl/login

• Opere! Almenu duverebbe. Avà pigliate u SecretID è pruvate à accede à a chjave / valore chì duvemu avè accessu.

curl 
consul-ds-client.default.svc.cluster.local/v1/kv/custom-ns/test_key --header “X-Consul-Token: <SecretID_from_prev_response>”

• Pudete basi64 decode "Value" è vede chì currisponde à u valore in custom-ns/test_key in l'UI. Se avete utilizatu u listessu valore sopra in stu tutoriale, u vostru valore codificatu seria IkknbSBpbiB0aGUgY3VzdG9tLW5zIGZvbGRlciEi.

Test di u contu di serviziu d'utilizatore:

• Crea un ServiceAccount persunalizatu cù u cumandimu seguitu [ссылка].

kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
 name: custom-sa
EOF

• Crea un novu schedariu di cunfigurazione per u pod. Per piacè nutate chì aghju inclusu l'installazione di curl per risparmià u travagliu :)

###poc-ubuntu-custom-sa.yaml
apiVersion: v1
kind: Pod
metadata:
 name: poc-ubuntu-custom-sa
 namespace: default
spec:
 serviceAccountName: custom-sa
 containers:
 - name: poc-ubuntu-custom-sa
   image: ubuntu
   command: ["/bin/bash","-ec"]
   args: ["apt-get update && apt-get install curl -y; sleep infinity"]
 restartPolicy: Never

• Dopu quì, fate una cunchiglia in u cuntinuu.

kubectl exec -it poc-ubuntu-custom-sa /bin/bash

• Accedi!

echo "{ 
"AuthMethod": "auth-method-skywiz-consul-poc", 
"BearerToken": "$(cat /run/secrets/kubernetes.io/serviceaccount/token)" 
}" 
| curl 
--request POST 
--data @- 
consul-ds-client.default.svc.cluster.local/v1/acl/login

• Permissione denegata. Oh, avemu scurdatu di aghjunghje una nova regule vincolante cù i permessi adatti, femu cusì avà.

Repetite i passi precedenti sopra:
a) Crea una Politica identica per u prefissu "custom-sa/".
b) Crea un rolu, chjamate "custom-sa-role"
c) Attach the Policy to the Role.

• Crea una Rule-Binding (solu pussibile da cli/api). Nota u significatu sfarente di a bandiera selettore.

consul acl binding-rule create 
-method=auth-method-skywiz-consul-poc 
-bind-type=role 
-bind-name='custom-sa-role' 
-selector='serviceaccount.name=="custom-sa"'

• Accedi di novu da u containeru "poc-ubuntu-custom-sa". Successu!
• Verificate u nostru accessu à u percorsu custom-sa / chjave.

curl 
consul-ds-client.default.svc.cluster.local/v1/kv/custom-sa/test_key --header “X-Consul-Token: <SecretID>”

• Pudete ancu assicurà chì stu token ùn dà micca accessu à kv in "custom-ns/". Basta à ripetiri u cumandimu supra dopu à rimpiazzà "custom-sa" cù u prefissu "custom-ns".
  Permissione denegata.

Esempiu di sovrapposizione:

• Vale a pena nutà chì tutti i mappings di ubligatoriu di regule seranu aghjuntu à u token cù questi diritti.
• U nostru cuntainer "poc-ubuntu-custom-sa" hè in u spaziu di nomi predeterminatu - allora l'utilicemu per un ligame di regule differente.
• Repetite i passi precedenti:
  a) Crea una Politica identica per u prefissu chjave "default /".
  b) Crea un rolu, chjamate "default-ns-role"
  c) Attach the Policy to the Role.
• Crea una Rule-Binding (solu pussibile da cli/api)

consul acl binding-rule create 
-method=auth-method-skywiz-consul-poc 
-bind-type=role 
-bind-name='default-ns-role' 
-selector='serviceaccount.namespace=="default"'

• Torna à u nostru containeru "poc-ubuntu-custom-sa" è pruvate à accede à u percorsu "default /" kv.
• Permissione denegata.
  Pudete vede e credenziali specificate per ogni token in l'UI sottu ACL> Tokens. Comu pudete vede, u nostru token attuale hà solu un "custom-sa-role" attaccatu à questu. U token chì simu attualmente utilizendu hè statu generatu quandu avemu cunnessu è ci era solu una regula chì currispondeva allora. Avemu bisognu di login di novu è aduprà u novu token.
• Assicuratevi chì pudete leghje da i percorsi kv "custom-sa/" è "default/".
  Successu!
  Questu hè perchè u nostru "poc-ubuntu-custom-sa" currisponde à l'associazioni di regule "custom-sa" è "default-ns".

cunchiusioni

Gestione di token TTL?

À u mumentu di sta scrittura, ùn ci hè micca un modu integratu per determinà u TTL per i tokens generati da stu metudu d'autorizazione. Saria una fantastica opportunità per furnisce l'automatizazione sicura di l'autorizazione Consul.

Ci hè una opzione per creà manualmente un token cù TTL:

• https://www.consul.io/docs/acl/acl-system.html#acl-tokens
  Tempu di scadenza - U tempu à quale stu token serà revucatu. (Opcional; aghjuntu in Consul 1.5.0)
• Esiste solu per a creazione / aghjurnamentu manuale https://www.consul.io/api/acl/tokens.html#expirationtime

Spergu chì in un futuru vicinu pudemu cuntrullà cumu si generanu i tokens (per regula o metudu d'autorizazione) è aghjunghje TTL.

Finu à quì, hè suggeritu chì utilizate un endpoint di logout in a vostra logica.

• https://www.consul.io/api/acl/acl.html#logout-from-auth-method
• https://www.consul.io/docs/acl/acl-auth-methods.html#overall-login-process

Leghjite ancu altri articuli nantu à u nostru blog:

• Chì hà purtatu a migrazione da ClickHouse senza autorizazione à ClickHouse cù l'autorizazione?
• Cumu eseguisce parechje pipeline cù GitLab CI/CD
• Trè trucchi facili per riduce l'imaghjini Docker
• Traefik cum'è controller Ingress per K8S
• Backup di un gran numaru di prughjetti web eterogenei
• Telegram bot per Redmine. Cumu fà a vita più faciule per sè stessu è per l'altri

Source: www.habr.com