Esegui il deployment del cluster ad alta affidabilità AlloyDB Omni sulle VM GCE utilizzando RPM Orchestrator

1. Introduzione

Questo codelab mostra il deployment del cluster ad alta affidabilità (HA) di AlloyDB Omni su macchine virtuali (VM) di Google Compute Engine (GCE). Al termine di questo codelab, eseguirai il provisioning di un'architettura di riferimento ad alta disponibilità composta da 3 nodi di database e 2 nodi HAProxy, insieme a un nodo di controllo per le operazioni di gestione.

Prerequisiti

  • Accesso a un progetto Google Cloud e a Cloud Shell dalla console Google Cloud.
  • Google Cloud SDK (gcloud) installato e configurato. Per maggiori dettagli sull'installazione di gcloud, consulta gcloud-install.
  • Terraform v1.9.8 installato.

Cosa imparerai a fare

  • Come creare e preparare le VM GCE per AlloyDB Omni.
  • Come installare ed eseguire l'orchestratore RPM di AlloyDB Omni.
  • Come installare e configurare gli RPM di AlloyDB Omni per l'architettura di riferimento ad alta disponibilità.

Che cosa ti serve

  • Ottieni il link URL agli RPM di AlloyDB Omni e all'orchestratore RPM. Per farlo, devi compilare il modulo di registrazione ad AlloyDB Omni. I link vengono inviati all'indirizzo email del server URL del repository. Inizializza le seguenti variabili di ambiente per tenere a portata di mano gli URL che verranno utilizzati durante il codelab.
    export ORCHESTRATOR_ANSIBLE_COLLECTION_PATH="..."
export ALLOYDB_OMNI_REPOSITORY_URL="..."
export ALLOYDB_OMNI_ORCHESTRATOR_REPOSITORY_URL="..."
export ALLOYDB_OMNI_COMMON_REPOSITORY_URL=....
export ETCD_REPOSITORY_URL="..."
  • Un terminale funzionante con accesso allo stack di deployment di AlloyDB Omni. A questo scopo, puoi utilizzare Cloud Shell.

2. Configurazione e requisiti

Configurazione del progetto

Crea un progetto Google Cloud

  1. Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud.
  2. Verifica che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è attivata per un progetto.

Avvia Cloud Shell

Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Dalla console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Icona per attivare Cloud Shell

In alternativa, puoi premere G, poi S. Questa sequenza attiverà Cloud Shell se ti trovi nella console Google Cloud o utilizzi questo link.

Il provisioning e la connessione all'ambiente dovrebbero richiedere solo pochi istanti. Al termine, dovresti vedere qualcosa di simile a questo:

Terminale Google Cloud Shell che mostra che l'ambiente è connesso

Questa macchina virtuale viene fornita con tutti gli strumenti di sviluppo di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non devi installare nulla.

3. Crea macchine virtuali Google Cloud Compute Engine

Prepara gli script Terraform

  1. Definisci le variabili di ambiente per l'ID progetto e il nome del cluster desiderato. Li utilizzerai durante il codelab.
    export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
    Nota: l'ID progetto Google Cloud deve contenere da 6 a 30 caratteri. Per ulteriori informazioni, consulta https://docs.cloud.google.com/resource-manager/docs/creating-managing-projects#before_you_begin.
  2. Assicurati di aver eseguito l'accesso con l'utente dell'account Google Cloud.
    gcloud auth login
  3. Crea una directory di lavoro per il deployment e copia i file di configurazione Terraform richiesti dall'origine del repository.
    mkdir -p ~/alloydb-omni/$PROJECT/$CLUSTER
cd ~/alloydb-omni/$PROJECT/$CLUSTER
gcloud storage cp gs://alloydb-omni-install/rpm-orchestrator/gce/terraform/*.tf .
  4. Crea un file terraform.tfvars per specificare i parametri richiesti in base all'architettura di riferimento, come indicato di seguito:
    cat > terraform.tfvars <<EOF
# Required instance counts for reference architecture
db_instance_count      = 3
haproxy_instance_count = 2
control_instance_count = 1

# Optional: Customize if needed with the below variables
# os_image             = "rocky-linux-cloud/rocky-linux-9"
# zone                 = "us-west4-c"
# region_1             = "us-west4"
# db_instance_type     = "c4-highmem-4"
# db_disk_type         = "hyperdisk-balanced"
# db_data_size         =  "50" # GB
# data_dir             =  "/data"
EOF

Esegui gli script Terraform e convalida

  1. Ora puoi eseguire il provisioning delle VM.
    terraform init
  2. Prima di creare le VM, assicurati di disporre dell'accesso necessario per creare VM e altre risorse. In sintesi, avrai bisogno delle seguenti autorizzazioni.
    roles/compute.admin
roles/iam.roleAdmin
roles/compute.osAdminLogin
roles/iam.serviceAccountCreator
roles/iam.serviceAccountUser
roles/artifactregistry.repoAdmin
roles/storage.objectUser
roles/resourcemanager.projectIamAdmin
roles/serviceusage.serviceUsageAdmin
  3. Convalida la configurazione e applicala per eseguire il provisioning delle risorse.
    terraform validate
terraform apply --auto-approve
    Nota: assicurati di utilizzare Terraform v1.9.8 come previsto dalla configurazione del deployment.
  4. Al termine dell'esecuzione di Terraform, verifica che le macchine virtuali siano state create correttamente elencando le istanze create utilizzando gcloud.
    gcloud compute instances list --filter="name~$CLUSTER" --project=$PROJECT
    Dovresti visualizzare le istanze corrispondenti ai 3 nodi di database, ai 2 nodi HAProxy e alla VM di controllo e alle zone corrispondenti. Annota la ZONA del nodo di controllo. Ne avremo bisogno più avanti in questo codelab.
    export ZONE=$(gcloud compute instances list \
  --filter="name=$CLUSTER-control"          \
  --format="value(zone)" --project=$PROJECT)

4. Prepara le VM per il deployment

Devi creare una sessione SSH sul nodo di controllo ed eseguire i passaggi per abilitare l'accesso SSH a tutte le VM (chiamate anche nodi).

  1. Assicurati che le variabili di ambiente per il progetto e il cluster siano definite.
    export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
  2. Crea la chiave SSH e aggiungila per accedere alla VM di controllo.
    # Replace values with your specific GCP project, cluster and zone details
ssh-keygen -t ed25519 -f $HOME/.ssh/google_compute_engine
gcloud compute os-login ssh-keys add --key-file=$HOME/.ssh/google_compute_engine.pub --project=$PROJECT
  3. Crea una regola firewall per consentire le connessioni SSH e il traffico VRRP.
    gcloud compute config-ssh --project=$PROJECT
gcloud compute firewall-rules create $CLUSTER-allow-ssh --network=$CLUSTER --project=$PROJECT --direction=INGRESS --action=allow --rules=tcp:22 --source-ranges="0.0.0.0/0"
gcloud compute firewall-rules create $CLUSTER-allow-vrrp --network=$CLUSTER --project=$PROJECT --allow=112 --source-ranges="0.0.0.0/0"
  4. Connettiti alla VM di controllo tramite SSH:
    gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
  5. Crea un gruppo Linux sul nodo di controllo con lo stesso nome dell'utente:
    sudo groupadd $(id -un)
sudo usermod -aG $(id -un) $(id -un)
  6. La configurazione di Terraform crea alcuni script di configurazione e li prepara nella directory /tmp/ della VM di controllo, inclusi elementi come il nome del cluster, il service account, il nome del progetto e così via.Crea l'accesso SSH senza password dai nodi di controllo a tutti i nodi del cluster utilizzando gli script di configurazione sul nodo di controllo.
    /tmp/setup-ssh-for-cluster.sh
    Importante: annota l'utente service_account. Lo utilizzeremo come SSH_USER più avanti in questo codelab.
  7. Per questo codelab, possiamo disabilitare SELinux su tutti i nodi. Lo script Terraform aggiunge "/tmp/run-all.sh", che può essere utilizzato a questo scopo.
    /tmp/run-all.sh sudo setenforce 0
  8. Se ti sei registrato ad AlloyDB Omni e hai ottenuto i link, è il momento di aggiungere anche questi URL alle variabili di ambiente.
    cat >> ~/.codelab.env <<EOF
export ORCHESTRATOR_ANSIBLE_COLLECTION_PATH="..."
export ALLOYDB_OMNI_REPOSITORY_URL="..."
export ALLOYDB_OMNI_ORCHESTRATOR_REPOSITORY_URL="..."
export ALLOYDB_OMNI_COMMON_REPOSITORY_URL=....
export ETCD_REPOSITORY_URL="..."
EOF
    Scegli un IP virtuale per il tuo ambiente dalla variabile di input cidr_range nel file terraform/variables.tf in modo che non sia in conflitto con gli altri nodi, come mostrato nell'esempio seguente:
    cat >> ~/.codelab.env <<EOF
export VIRTUAL_IP="10.1.0.50"
EOF

5. Installa i componenti software richiesti su tutte le VM

Il passaggio successivo consiste nell'installare i componenti software richiesti sulle VM. Questa operazione può essere coordinata sul nodo di controllo. Tutti i comandi seguenti devono essere eseguiti sul nodo di controllo.

  1. Connettiti alla VM di controllo tramite SSH, se non hai già eseguito l'accesso al nodo di controllo.
    gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
    Una volta visualizzato il prompt SSH della VM di controllo, carica il file di ambiente.
    source ~/.codelab.env
  2. Sul nodo di controllo, installa Ansible e le librerie Python richieste.
    sudo dnf install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm -y
sudo dnf install -y ansible
sudo dnf install -y python3-grpcio python3-protobuf python3-googleapis-common-protos python3-grpcio-status
  3. Scarica il file tar della raccolta Ansible dell'orchestratore RPM e installalo.
    gcloud storage cp "gs://${ORCHESTRATOR_ANSIBLE_COLLECTION_PATH#https://storage.googleapis.com/}google-alloydbomni_orchestrator-*.tar.gz" .
ansible-galaxy collection install google-alloydbomni_orchestrator-0.1.0-6.tar.gz
ansible-galaxy collection list | grep alloydbomni_orchestrator
    Nota: assicurati che la variabile ORCHESTRATOR_ANSIBLE_COLLECTION_PATH termini con "/".
  4. L'orchestratore utilizza un file di specifiche di deployment in formato inventario Ansible per comprendere la topologia del cluster. Crea un file denominato deployment_spec.yaml con i dettagli del nodo sul nodo di controllo.
    cat > deployment_spec.yaml <<EOF
alloydbomni:
  vars:
    cluster_manager:
      name: "$CLUSTER"
    etcd:
      setup: true
      config_forcewrite: true
    alloydbomni:
      major_version: "18"
      repo_url: $ALLOYDB_OMNI_REPOSITORY_URL
    alloydbomni_monitor:
      repo_url: $ALLOYDB_OMNI_COMMON_REPOSITORY_URL
    alloydbomni_cluster_manager:
      repo_url: $ALLOYDB_OMNI_ORCHESTRATOR_REPOSITORY_URL
    alloydbomni_node_manager:
      repo_url: $ALLOYDB_OMNI_ORCHESTRATOR_REPOSITORY_URL
    pgbouncer:
      repo_url: $ALLOYDB_OMNI_COMMON_REPOSITORY_URL
    pgbackrest:
      repo_url: $ALLOYDB_OMNI_COMMON_REPOSITORY_URL

  children:
    primary_instance_nodes:
      hosts:
        $CLUSTER-db1:
        $CLUSTER-db2:
        $CLUSTER-db3:
    load_balancer_nodes:
      hosts:
        $CLUSTER-haproxy1:
        $CLUSTER-haproxy2:
EOF
    Nota: esamina il file generato per assicurarti che faccia riferimento a valori validi.
  5. Crea un playbook denominato install.yaml che faccia riferimento al ruolo di installazione della raccolta dell'orchestratore.
    cat > install.yaml <<EOF
- name: Install AlloyDB Omni cluster components
  hosts: all
  vars:
    ansible_become: true
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  roles:
    - role: google.alloydbomni_orchestrator.install
EOF
    Nota: esamina il file generato per assicurarti che faccia riferimento a valori validi.
  6. Esegui il playbook utilizzando il file di inventario per scaricare e installare gli RPM su tutti i nodi specificati.
    ansible-playbook -i deployment_spec.yaml install.yaml

6. Esegui il bootstrap del cluster AlloyDB Omni

A questo punto, abbiamo installato tutti i componenti richiesti su tutti i nodi. Siamo pronti per eseguire il bootstrap del cluster AlloyDB Omni.

  1. Connettiti alla VM di controllo tramite SSH, se non hai già eseguito l'accesso al nodo di controllo.
    gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
    Una volta visualizzato il prompt SSH della VM di controllo, carica il file di ambiente.
    source ~/.codelab.env
  2. Genera un hash per la password e annotalo.
    encoded_password=$(echo -n "your unique password" | base64)
  3. Per creare il cluster, AlloyDB Omni deve sapere come configurarlo. Crea un file denominato dbcluster.yaml per le specifiche del cluster di database.
    cat > dbcluster.yaml <<EOF
Secret:
  metadata:
    name: db-pw-$CLUSTER
  spec:
    type: Opaque
    data:
      $CLUSTER: $encoded_password
---
DBCluster:
  metadata:
    name: $CLUSTER
  spec:
    databaseVersion: 18.1.0
    mode: ""
    availability:
      numberOfStandbys: 2
      enableAutoFailover: true
      enableAutoHeal: true
      autoFailoverTriggerThreshold: 2
      autoHealTriggerThreshold: 2
      healthcheckPeriodSeconds: 5
      replayReplicationSlotsOnStandbys: false
    primarySpec:
      adminUser:
        passwordRef:
          name: db-pw-$CLUSTER
      resources:
        cpu: 4
        memory: 32Gi
        disks:
        - name: DataDisk
          path: $PGDATA
      dbLoadBalancerOptions:
        gcp:
          loadBalancerIP: "$VIRTUAL_IP"
          loadBalancerType: "internal"
          loadBalancerInterface: "eth0"
EOF
  4. Crea un playbook denominato bootstrap.yaml, che farà riferimento al ruolo Ansible di bootstrap per la creazione del cluster AlloyDB Omni.
    cat > bootstrap.yaml <<EOF
- name: Create DBCluster
  hosts: localhost
  vars:
    ansible_become: true
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  roles:
  - role: google.alloydbomni_orchestrator.bootstrap
EOF
  5. Esegui il playbook per creare il cluster.
    ansible-playbook bootstrap.yaml -i deployment_spec.yaml -e resource_spec=dbcluster.yaml

7. (Facoltativo) Configura il pool di connessioni PgBouncer

AlloyDB Omni supporta il pool di connessioni leggero utilizzando PgBouncer. Puoi configurare ed eseguire il bootstrap di PgBouncer subito dopo il provisioning del cluster.

  1. Crea un file di specifiche delle risorse denominato pgbouncer.yaml che associa il pool di connessioni al cluster di database:
    cat > pgbouncer.yaml <<EOF
PgBouncer:
  metadata:
    name: pgbouncer-pooler
  spec:
    dbclusterRef: $CLUSTER
    allowSuperUserAccess: true
    accessMode: "rw"
    port: 6432
EOF
  2. Esegui il bootstrap del pool di PgBouncer utilizzando lo stesso playbook bootstrap.yaml creato in precedenza, passando il nuovo file di specifiche:
    ansible-playbook bootstrap.yaml -i deployment_spec.yaml -e resource_spec=pgbouncer.yaml

8. Verifica il cluster AlloyDB Omni

Per verificare che il cluster funzioni correttamente e sia accessibile utilizzando il bilanciatore del carico, puoi connetterti utilizzando il client PostgreSQL standard dal nodo di controllo.

  1. Installa il repository e il pacchetto del client PostgreSQL 18 sul nodo di controllo:
    sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
sudo dnf install -y postgresql18
  2. Connettiti al cluster utilizzando l'IP virtuale riservato in precedenza. Ti verrà richiesta la password codificata in dbcluster.yaml:
    /usr/pgsql-18/bin/psql -h $VIRTUAL_IP -U postgres -W
  3. Una volta connesso, puoi eseguire query SQL di base per verificare lo stato del cluster, ad esempio controllando la versione del database:
    postgres=# SELECT version();
    Dovresti vedere un output che indica che PostgreSQL 18 è in esecuzione con AlloyDB Omni. Digita \q per uscire dal prompt.

9. (Facoltativo) Esegui il backup dei dati utilizzando pgBackRest

AlloyDB Omni si integra con pgBackRest per gestire i backup direttamente in Cloud Storage. Puoi configurare un piano di backup e attivare un backup on demand nel bucket GCS creato dalla configurazione di Terraform.

  1. Crea un file di specifiche del piano di backup denominato backup_plan.yaml che rimandi al bucket GCS di cui hai eseguito il provisioning:
    cat > backup_plan.yaml <<EOF
BackupPlan:
  metadata:
    name: pgb-plan
  spec:
    dbclusterRef: $CLUSTER
    backupLocation:
      type: GCS
      gcsOptions:
        bucket: $CLUSTER-gcs-backups
        key: /backups
EOF
  2. Crea un playbook Ansible denominato backup.yaml che faccia riferimento al ruolo di gestione dei backup:
    cat > backup.yaml <<EOF
- name: Manage AlloyDB Omni Backups
  hosts: localhost
  vars:
    ansible_become: true
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  roles:
    - role: google.alloydbomni_orchestrator.backup
EOF
  3. Applica il piano di backup utilizzando il playbook backup.yaml:
    ansible-playbook backup.yaml -i deployment_spec.yaml -e resource_spec=backup_plan.yaml
  4. Una volta stabilito il piano, crea un file di risorse di backup on demand denominato create_backup.yaml.
    cat > create_backup.yaml <<EOF
Backup:
  metadata:
    name: on-demand-backup
  spec:
    backupPlanRef: pgb-plan
    dbclusterRef: $CLUSTER
EOF
  5. Esegui il playbook per avviare il backup:
    ansible-playbook backup.yaml -i deployment_spec.yaml -e resource_spec=create_backup.yaml
  6. Per verificare lo stato del backup, crea un playbook status.yaml:
- name: Fetch AlloyDB Omni Resource Status
hosts: localhost
vars:
  ansible_become: true
  ansible_user: $SSH_USER
  ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
roles:
  - role: google.alloydbomni_orchestrator.status
EOF
  1. Esegui il playbook per elencare tutti i backup:
ansible-playbook status.yaml -i deployment_spec.yaml -e resource_type=Backup
  1. In alternativa, per ottenere informazioni dettagliate su un backup specifico creato in precedenza, passa -e resource_name=on-demand-backup:
ansible-playbook status.yaml -i deployment_spec.yaml \
  -e resource_type=Backup \
  -e resource_name=on-demand-backup

10. Esegui la pulizia delle risorse

Al termine del deployment, puoi eliminare le risorse di cui hai eseguito il provisioning per evitare addebiti.

  1. Crea un playbook denominato teardown.yaml:
    cat > teardown.yaml <<EOF
- name: Tear down AlloyDB Omni cluster
  hosts: localhost
  vars:
    ansible_become: true
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  roles:
  - role: google.alloydbomni_orchestrator.delete
EOF
  2. Esegui il playbook utilizzando ansible-playbook. Se hai configurato i backup, elimina prima le risorse Backup e BackupPlan:
    ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=Backup" -e "resource_name=on-demand-backup"
ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=BackupPlan" -e "resource_name=pgb-plan"
    Se hai configurato PgBouncer, elimina la risorsa del pool di connessioni:
    ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=PgBouncer" -e "resource_name=pgbouncer-pooler"
    Quindi, specifica DBCluster come resource_type ed elimina il cluster di database stesso:
    ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=DBCluster" -e "resource_name=$CLUSTER"
  3. Una volta eliminato il cluster, disconnettiti dal nodo di controllo, torna al terminale e vai alla directory di lavoro di Terraform.
    Nota: se hai appena eseguito l'accesso a Cloud Shell, ricordati di impostare quanto segue:
    export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
  4. Elimina la regola firewall VRRP ed elimina le risorse gestite da Terraform:
    gcloud compute firewall-rules delete -q "$CLUSTER-allow-vrrp" --project="$PROJECT"
gcloud compute firewall-rules delete -q "$CLUSTER-allow-ssh" --project="$PROJECT"
terraform destroy
  5. Conferma l'eliminazione quando ti viene richiesto. Poiché le risorse o le route di rete rimanenti potrebbero occasionalmente impedire l'eliminazione completa, esegui i seguenti comandi di pulizia sicura per assicurarti che tutte le regole firewall, i gateway NAT, i router, le route, le subnet e le reti associate vengano rimosse completamente. Sostituisci REGION con la regione di deployment specifica, ad esempio "us-central1":
    # Delete any remaining firewall rules associated with the cluster
gcloud compute firewall-rules list --project=$PROJECT 2> /dev/null | grep ^$CLUSTER- | cut -f1 -d' ' | \
  while read rule; do gcloud compute firewall-rules delete --project=$PROJECT --quiet $rule; done

# Delete the Cloud NAT gateway and router if they still exist
gcloud compute routers nats describe $CLUSTER-nat-gw --router=$CLUSTER-router --region=REGION --project=$PROJECT 2>/dev/null \
  && gcloud compute routers nats delete $CLUSTER-nat-gw --router=$CLUSTER-router --region=REGION --project=$PROJECT --quiet

gcloud compute routers describe $CLUSTER-router --region=REGION --project=$PROJECT 2>/dev/null \
  && gcloud compute routers delete $CLUSTER-router --region=REGION --project=$PROJECT --quiet

# Delete any remaining custom routes
gcloud compute routes list --project=$PROJECT --filter="network:$CLUSTER" --format="value(name)" 2>/dev/null | \
  while read route; do gcloud compute routes delete --project=$PROJECT --quiet $route 2>/dev/null || true; done

# Delete the subnet and network if they still exist
gcloud compute networks subnets describe $CLUSTER --region=REGION --project=$PROJECT 2>/dev/null \
  && gcloud compute networks subnets delete $CLUSTER --region=REGION --project=$PROJECT --quiet

gcloud compute networks describe $CLUSTER --project $PROJECT 2> /dev/null \
  && gcloud compute networks delete $CLUSTER --project $PROJECT --quiet

11. Complimenti

Complimenti per aver completato il codelab.

Argomenti trattati

  • Come creare e preparare le VM GCE per AlloyDB Omni.
  • Come installare ed eseguire l'orchestratore RPM di AlloyDB Omni.
  • Come installare e configurare gli RPM di AlloyDB Omni per l'architettura di riferimento ad alta disponibilità.

Puoi scoprire di più su AlloyDB Omni nella documentazione.

12. Sondaggio

Come utilizzerai questo tutorial?

Lo leggerò solo Lo leggerò e completerò gli esercizi