Informazioni su Skaffold

1. Obiettivi

Skaffold è uno strumento che gestisce il flusso di lavoro per la creazione, il push e il deployment della tua applicazione. Puoi utilizzare Skaffold per configurare facilmente uno spazio di lavoro di sviluppo locale, semplificare il ciclo di sviluppo interno e integrare altri strumenti come Kustomize e Helm per gestire i manifest di Kubernetes.

In questo tutorial esamini alcuni concetti fondamentali di Skaffold, lo utilizzi per automatizzare il ciclo di sviluppo interno e poi esegui il deployment di un'applicazione.

Imparerai a:

• Configura e abilita Skaffold per lo sviluppo locale
• Crea ed esegui una semplice applicazione Golang
• Gestire il deployment delle applicazioni locali con Skaffold
• Esegui il rendering dei manifest ed esegui il deployment della tua applicazione

2. Prima di iniziare

Preparazione dell'area di lavoro

1. Apri l'editor di Cloud Shell visitando il seguente URL:

https://shell.cloud.google.com

Consenti i cookie di terze parti. Fai clic su "Il sito non funziona" e poi su "Consenti cookie".

2. Se non lo hai già fatto, nella finestra del terminale clona il codice sorgente dell'applicazione con il seguente comando:

git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git

3. Passa alla directory del repository clonato:

cd software-delivery-workshop/labs/understanding-skaffold/getting-started

4. Imposta la tua area di lavoro Cloud Shell sulla directory corrente eseguendo il seguente comando:

cloudshell workspace .

Preparazione del progetto

1. Assicurati che il progetto Google Cloud sia impostato correttamente eseguendo il seguente comando:

gcloud config set project {{project-id}}

3. Iniziare a utilizzare Skaffold

1. Esegui questo comando per creare il file di configurazione Skaffold di primo livello, skaffold.yaml:

cat <<EOF > skaffold.yaml
apiVersion: skaffold/v2beta21
kind: Config
metadata:
  name: getting-started-kustomize
build:
  tagPolicy:
    gitCommit:
      ignoreChanges: true
  artifacts:
  - image: skaffold-kustomize
    context: app
    docker:
      dockerfile: Dockerfile
deploy:
  kustomize:
    paths:
    - overlays/dev
profiles:
- name: staging
  deploy:
    kustomize:
      paths:
      - overlays/staging
- name: prod
  deploy:
    kustomize:
      paths:
      - overlays/prod
EOF

2. Apri il file skaffold.yaml nel riquadro dell'IDE. Si tratta del file di configurazione di primo livello che definisce la pipeline Skaffold.

Nota il formato YAML simile a Kubernetes e le seguenti sezioni nel file YAML:

• build
• deploy
• profiles

Queste sezioni definiscono la modalità di compilazione e di deployment dell'applicazione, nonché i profili per ogni target di deployment.

Puoi scoprire di più sull'elenco completo delle fasi di Skaffold nella documentazione relativa alle fasi della pipeline di Skaffold.

4. Build

La sezione build contiene la configurazione che definisce la modalità di compilazione dell'applicazione. In questo caso, puoi vedere la configurazione di come devono essere gestiti i tag git, nonché una sezione artifacts che definisce le immagini container che compongono l'applicazione.

Inoltre, in questa sezione puoi vedere il riferimento al Dockerfile da utilizzare per creare le immagini. Skaffold supporta anche altri strumenti di creazione come Jib, Maven, Gradle, Buildpacks, Bazel cloud-native e script personalizzati. Per saperne di più su questa configurazione, consulta la documentazione di Skaffold Build.

5. Esegui il deployment

La sezione deploy contiene la configurazione che definisce la modalità di deployment dell'applicazione. In questo caso, puoi vedere un esempio di deployment predefinito che configura Skaffold per utilizzare lo strumento Kustomize.

Lo strumento Kustomize fornisce funzionalità per la generazione di manifest Kubernetes combinando un insieme di file YAML dei componenti comuni (nella directory base) con uno o più "overlay" che in genere corrispondono a uno o più target di deployment, in genere dev, test, staging e production o simili.

In questo esempio puoi vedere due overlay per tre target: dev, staging e prod. L'overlay dev verrà utilizzato durante lo sviluppo locale, mentre gli overlay staging e prod verranno utilizzati per il deployment con Skaffold.

6. Profili

La sezione profiles contiene la configurazione che definisce le configurazioni di compilazione, test e implementazione per contesti diversi. In genere, i contesti diversi sono ambienti diversi nella pipeline di deployment dell'applicazione, come staging o prod in questo esempio. Ciò significa che puoi gestire facilmente i manifest i cui contenuti devono essere diversi per ambienti di destinazione diversi, senza ripetere la configurazione boilerplate.

La configurazione nella sezione profiles può sostituire o correggere eventuali elementi della configurazione principale (ad es. le sezioni build, test o deploy).

Ad esempio, apri il file overlays > prod > deployment.yaml. Tieni presente che il numero di repliche per l'applicazione è configurato su tre, sostituendo la configurazione di base.

Navigare nel codice sorgente dell'applicazione.

1. Apri il seguente file app > main.go nel riquadro IDE. Si tratta di una semplice applicazione Golang che scrive una stringa in stdout ogni secondo.
2. Tieni presente che l'applicazione stampa anche il nome del pod Kubernetes in cui è in esecuzione.

Visualizzazione del Dockerfile

1. Apri il file app > Dockerfile nel riquadro IDE. Questo file contiene una sequenza di direttive per creare l'immagine del contenitore dell'applicazione per il file main.go e viene fatto riferimento al file skaffold.yaml di primo livello.

7. Sviluppo con Skaffold

Configurazione dell'ambiente Kubernetes

1. Esegui questo comando per assicurarti che il tuo cluster Kubernetes locale sia in esecuzione e configurato:

minikube start

L'operazione potrebbe richiedere diversi minuti. Se il cluster si è avviato correttamente, dovresti vedere il seguente output:

Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

2. Esegui il seguente comando per creare spazi dei nomi Kubernetes per dev, staging e prod:

kubectl apply -f namespaces.yaml

Dovresti vedere l'output seguente:

namespace/dev created
namespace/staging created
namespace/prod created

Utilizzo di Skaffold per lo sviluppo locale

1. Esegui il seguente comando per compilare l'applicazione ed eseguirne il deployment in un cluster Kubernetes locale in esecuzione in Cloud Shell:

skaffold dev

Dovresti vedere l'esecuzione della procedura di compilazione del contenitore dell'applicazione, che potrebbe richiedere un minuto, e poi l'output dell'applicazione che si ripete ogni secondo:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-dev-xxxxxxxxx-xxxxx

Tieni presente che il nome esatto del pod varierà dall'output generico riportato sopra.

Apportare modifiche all'applicazione

Ora che l'applicazione è in esecuzione nel tuo cluster Kubernetes locale, puoi apportare modifiche al codice e Skaffold ne eseguirà automaticamente la ricostruzione e il nuovo deployment nel cluster.

1. Apri il file app > main.go nel riquadro dell'IDE e modifica la stringa di output:

"Hello world from pod %s!\n"

a:

"Hello Skaffold world from pod %s!\n"

Dopo aver apportato la modifica, dovresti vedere Skaffold ricreare l'immagine ed eseguirne nuovamente il deployment nel cluster. La modifica dell'output è visibile nella finestra del terminale.

2. Ora, anche nel file "app > main.go" nel riquadro dell'IDE, modifica la riga:

time.Sleep(time.Second * 1)

a

time.Sleep(time.Second * 10)

Anche in questo caso, dovresti vedere l'applicazione ricreata e rieseguire il deployment, con la riga di output visualizzata una volta ogni 10 secondi.

Modificare la configurazione di Kubernetes

Ora apporterai una modifica alla configurazione di Kubernetes e rieseguire automaticamente il deployment di Skaffold.

1. Apri il file base > deployment.yaml nell'IDE e modifica la riga:

replicas: 1

a

replicas: 2

Una volta eseguito nuovamente il deployment dell'applicazione, dovresti vedere due pod in esecuzione, ognuno con un nome diverso.

2. Ora, ripristina la stessa riga nel file base > deployment.yaml:

replicas: 1

Dovresti vedere uno dei pod rimosso dal servizio, in modo che ne rimanga solo uno.

3. Infine, premi Ctrl-C nella finestra del terminale per interrompere lo sviluppo locale di Skaffold.

Tagliare una release

Successivamente, creerai una release creando un'immagine di release ed eseguendone il deployment in un cluster.

1. Esegui il comando seguente per compilare la release:

skaffold build --file-output artifacts.json

Questo comando genera l'immagine finale (se necessario) e restituisce i dettagli della release nel file artifacts.json.

Se vuoi utilizzare uno strumento come Cloud Deploy per eseguire il deployment nei tuoi cluster, questo file contiene le informazioni sulla release. Ciò significa che gli elementi non possono essere modificati nel percorso verso la pubblicazione.

2. Esegui il comando seguente per visualizzare i contenuti del file artifacts.json:

cat artifacts.json | jq

Tieni presente che il file contiene il riferimento all'immagine che verrà utilizzata nel deployment finale.

Eseguire il deployment nella gestione temporanea

1. Esegui questo comando per eseguire il deployment della release utilizzando il profilo staging:

skaffold deploy --profile staging --build-artifacts artifacts.json --tail

Una volta completato il deployment, dovresti vedere l'output di due pod, simili al seguente:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-staging-xxxxxxxxxx-xxxxx!

2. Premi Ctrl-C nella finestra del terminale per interrompere l'output di Skaffold.
3. Esegui questo comando per osservare che la tua applicazione è attiva e in esecuzione nel cluster:

kubectl get all --namespace staging

Dovresti vedere due nomi di pod distinti, perché il profilo staging per l'applicazione specifica che nel deployment devono essere presenti due repliche.

Esegui il deployment in produzione

1. Ora esegui il comando seguente per eseguire il deployment della release utilizzando il profilo prod:

skaffold deploy --profile prod --build-artifacts artifacts.json --tail

Al termine del deployment, dovresti vedere l'output di tre pod simile al seguente:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-prod-xxxxxxxxxx-xxxxx!

2. Premi Ctrl+C nella finestra del terminale per interrompere l'output di Skaffold.

Dovresti vedere tre nomi di pod distinti, perché il profilo prod per l'applicazione specifica che il deployment deve contenere tre repliche.

3. Esegui il seguente comando per verificare che l'applicazione sia in esecuzione nel cluster:

kubectl get all --namespace prod

Dovresti vedere un output contenente righe simili alle seguenti che mostrano il deployment di produzione:

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/skaffold-kustomize-prod   3/3     3            3           16m

Dovresti anche vedere tre pod dell'applicazione in esecuzione.

NAME                                           READY   STATUS    RESTARTS   AGE
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m

8. Complimenti!

Complimenti! Hai completato il lab Understanding Skaffold e hai imparato a configurare e utilizzare Skaffold per lo sviluppo locale e il deployment delle applicazioni.

Passaggi successivi

Scopri di più su Skaffold:

• Approfondimento su Skaffold

Esegui la pulizia

1. Esegui il seguente comando per arrestare il cluster locale:

minikube delete