Avvio automatico del mirroring pacchetto per il monitoraggio delle applicazioni

Questo tutorial mostra come utilizzare Cloud Logging, Pub/Sub e Cloud Functions per attivare automaticamente Mirroring patch in modo da poter monitorare e risolvere i problemi relativi ai flussi di traffico nella tua rete Virtual Private Cloud (VPC). Questo tutorial è destinato ai team di rete, sicurezza e DevOps. Si presume che tu abbia dimestichezza con Cloud Logging, Pub/Sub, Cloud Functions, Mirroring pacchetto, Compute Engine e Terraform.

Introduzione

Mirroring pacchetto è una funzionalità che consente di monitorare i flussi di traffico VPC in tempo reale. Con il mirroring pacchetto, i team DevOps possono risolvere i problemi di prestazioni ridotte o traffico che genera messaggi di errore oppure le aziende sensibili alla sicurezza possono osservare e reagire a pattern di traffico che potrebbero essere dannosi. Le organizzazioni spesso utilizzano il mirroring pacchetto insieme a un sistema di rilevamento delle intrusioni (IDS) per rilevare e mitigare le minacce.

Mirroring pacchetto acquisisce tutto il traffico in entrata e in uscita e i dati dei pacchetti (come payload e intestazioni), quindi esporta il traffico, fornendoti la piena visibilità della rete. Puoi inviare il traffico con mirroring fuori banda alle appliance di sicurezza e monitoraggio che ti aiutano a rilevare minacce, monitorare le prestazioni della rete e risolvere i problemi delle applicazioni.

Puoi eseguire il mirroring pacchetto a livello di subnet, su tag di rete o su istanze VPC specifiche. Puoi eseguire il mirroring continuo dei pacchetti o abilitare e disabilitare il mirroring pacchetto in base agli attivatori predefiniti.

In questo tutorial, configurerai l'architettura nel diagramma seguente.

Il traffico Internet viene instradato attraverso il bilanciatore del carico globale al VPC di mirroring dei pacchetti.

Questa architettura prevede il seguente flusso di lavoro:

  1. Viene inviata una richiesta non valida al bilanciatore del carico, che attiva un codice di stato HTTP 500 Internal Server Error dai server web.
  2. Cloud Monitoring genera un evento e Cloud Logging registra un messaggio di errore.
  3. Pub/Sub, configurato come sink per Cloud Monitoring, riceve il messaggio di errore.
  4. Cloud Monitoring esegue il push di un evento in Pub/Sub, attivando Cloud Functions per abilitare il mirroring pacchetto.
  5. Mirroring pacchetto è abilitato e il traffico viene sottoposto a mirroring nelle VM del raccoglitore, in modo che una persona o un team appropriato possa esaminare ulteriormente i messaggi di errore. In questo tutorial, utilizzerai l'utilità tcpdump per esaminare i pacchetti acquisiti.

Per completare questo tutorial, utilizzerai Terraform Terraform di HashiCorp per creare il VPC, le subnet, il bilanciatore del carico globale, il server web e la VM del raccoglitore. Quindi, configurerai manualmente un criterio di Mirroring pacchetto e le VM del raccoglitore associate per ricevere il traffico di cui viene eseguito il mirroring. Infine, devi configurare Cloud Logging, Cloud Functions e Pub/Sub in modo che attivi il Mirroring pacchetto.

Anche se questo tutorial mostra i possibili risultati quando utilizzi un codice messaggio di errore (HTTP 500) per attivare un evento, puoi personalizzare questa soluzione per altri casi d'uso e ambienti. Ad esempio, potresti voler attivare il logging in modo da poter esaminare i pattern (come un pattern regex specifico) o le metriche delle applicazioni (come l'utilizzo di CPU e memoria).

Per scoprire di più su come configurare Cloud Monitoring e Cloud Logging, consulta la documentazione Cloud Logging e Cloud Monitoring.

Obiettivi

  • Eseguire il deployment di un ambiente di base tramite Terraform.
  • Configura l'infrastruttura di mirroring dei pacchetti.
  • Attivano un messaggio di errore dell'applicazione.
  • Verifica che il mirroring pacchetto sia attivo.
  • Mostra un'acquisizione di pacchetti sulle istanze Compute Engine del raccoglitore.

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono beneficiare di una prova gratuita.

Al termine di questo tutorial, puoi evitare una fatturazione continua eliminando le risorse che hai creato. Per scoprire di più, vedi Pulizia.

Prima di iniziare

  1. Nella console, attiva Cloud Shell.

    Attiva Cloud Shell

    La maggior parte di questo tutorial viene completata dal terminale Cloud Shell utilizzando Terraform e l'interfaccia a riga di comando di Google Cloud.

  2. In Cloud Shell, modifica la directory di lavoro locale e clona il repository GitHub:

    cd $HOME
    git clone https://github.com/GoogleCloudPlatform/terraform-gce-packetmirror.git packetMirror
    

    Il repository contiene tutti i file necessari per completare il tutorial. Per una descrizione completa di ogni file, consulta il file README.md nel repository.

  3. Rendi eseguibili tutti gli script shell:

    cd $HOME/packetMirror
    sudo chmod 755 *.sh
    
  4. Assicurati che l'account utente che utilizzi per questo tutorial disponga delle autorizzazioni IAM (Gestione di identità e accessi) necessarie per completare il tutorial.

Preparazione dell'ambiente

In questa sezione configurerai le variabili di ambiente ed eseguirai il deployment dell'infrastruttura di supporto.

Configurare Terraform

  1. Installa Terraform seguendo i passaggi descritti nella documentazione di HashiCorp.
  2. In Cloud Shell, inizializza Terraform:

    terraform init
    

    L'output è simile al seguente:

    ...
    Initializing provider plugins...
    The following providers do not have any version constraints in configuration, so the latest version was installed.
    ...
    Terraform has been successfully initialized!
    ...
    

Imposta le variabili di ambiente

  1. Se il tuo account utente Google Cloud fa parte di un'organizzazione Google Cloud, esegui i comandi seguenti in Cloud Shell:

    1. Imposta la variabile TF_VAR_org_id sul nome della tua organizzazione Google Cloud:

      export TF_VAR_org_id=$(gcloud organizations list \
          --format="value(ID)" \
          --filter="DISPLAY_NAME:YOUR_ORGANIZATION_NAME")
      

      Sostituisci YOUR_ORGANIZATION_NAME con il nome dell'organizzazione Google Cloud che vuoi utilizzare in questo tutorial.

    2. Aggiungi la variabile Terraform org_id alla risorsa di progetto:

      sed -i "s/#org_id          = var.org_id/org_id          = var.org_id/" main.tf
      
    3. Verifica di avere impostato correttamente la variabile di ambiente:

      echo $TF_VAR_org_id
      

      L'output elenca il tuo ID organizzazione numerico e ha un aspetto simile al seguente:

      ...
      123123123123
      ...
      
  2. Imposta il nome dell'account di fatturazione:

    1. Elenca i tuoi account di fatturazione attivi:

      gcloud beta billing accounts list
      

      Copia il nome dell'account di fatturazione che vuoi utilizzare per il tutorial. Questo nome è necessario per il passaggio successivo.

    2. Imposta la variabile di ambiente dell'account di fatturazione:

      TF_VAR_billing_name="YOUR_BILLING_ACCOUNT_NAME"
      export TF_VAR_billing_name
      

      Sostituisci YOUR_BILLING_ACCOUNT_NAME con il nome del nome dell'account di fatturazione che hai copiato nel passaggio precedente.

  3. Imposta le variabili di ambiente rimanenti:

    source $HOME/packetMirror/set_variables.sh
    
  4. Verifica di avere impostato correttamente le variabili di ambiente:

    env | grep TF_
    

    L'output è simile al seguente:

    ...
    TF_VAR_billing_account=YOUR_BILLING_ACCOUNT_NAME
    TF_VAR_org_id=YOUR_ORGANIZATION_NAME
    TF_VAR_region=YOUR_REGION
    TF_VAR_user_account=YOUR_USER_ACCOUNT
    TF_VAR_pid=YOUR_PROJECT_ID
    TF_VAR_zone=YOUR_ZONE
    ...
    

    In questo output:

    • YOUR_REGION: l'area geografica del tuo progetto Google Cloud, ad esempio us-west1
    • YOUR_USER_ACCOUNT: il tuo ID account, ad esempio user@example
    • YOUR_PROJECT_ID: ID progetto Cloud
    • YOUR_ZONE: la zona del tuo progetto Cloud, ad esempio us-west1-b
  5. Se la variabile TF_VAR_billing_account non è impostata correttamente, nella console, vai alla pagina Panoramica dell'account di fatturazione nella gestione degli account di fatturazioneimposta l'ID, quindi la variabile seguente:

    export TF_VAR_billing_account=BILLING_ACCOUNT_ID
    

    Sostituisci BILLING_ACCOUNT_ID con l'ID account che hai copiato in precedenza in questo passaggio.

  6. Crea un file della variabile di ambiente:

    $HOME/packetMirror/saveVars.sh
    

    Questo comando reindirizza le variabili di ambiente che hai creato in un file denominato TF_ENV_VARS. Ogni variabile è preceduta dal comando export. Se la sessione di Cloud Shell viene terminata, puoi utilizzare questo file per reimpostare le variabili. Queste variabili vengono utilizzate dagli script Terraform, dagli script Cloud Shell e dall'interfaccia a riga di comando di Google Cloud.

    Se devi inizializzare le variabili in un secondo momento, puoi eseguire il seguente comando:

    source $HOME/packetMirror/TF_ENV_VARS
    

Eseguire il deployment dell'infrastruttura base

  1. In Cloud Shell, esegui il deployment dell'infrastruttura di supporto Terraform:

    cd $HOME/packetMirror
    terraform apply
    
  2. Quando ti viene richiesto, inserisci yes per applicare una delle due configurazioni.

    Il comando terraform apply indica a Terraform di eseguire il deployment di progetto, reti, subnet, bilanciatore del carico globale e server web. Per capire come l'infrastruttura è definita in modo dichiarativo, puoi leggere i manifest manifest di Terraform (file con estensione .tf).

    Il deployment dei componenti Terraform può richiedere diversi minuti. Vengono creati i seguenti oggetti:

    • VPC
    • Regole firewall
    • Subnet
    • Modello di istanza per il server web
    • Gruppo di istanze gestite per i server web
    • Gruppo di istanze non gestite per le VM del raccoglitore
    • Cloud NAT
    • Bilanciatore del carico globale e controlli di integrità associati

    Puoi sfogliare il progetto per visualizzare questi elementi tramite la console o utilizzando i comandi gcloud.

Creazione di risorse di mirroring pacchetto

Nei passaggi seguenti puoi creare e verificare l'infrastruttura di mirroring dei pacchetti.

Creare risorse di bilanciamento del carico interne del raccoglitore

  • In Cloud Shell, crea il servizio di backend e la regola di forwarding:

    gcloud compute backend-services create collector-ilb \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --load-balancing-scheme=internal \
        --protocol=tcp \
        --health-checks=http-basic-check
    
    gcloud compute backend-services add-backend collector-ilb \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --instance-group=collector-ig \
        --instance-group-zone="$TF_VAR_zone"
    
    gcloud compute forwarding-rules create fr-ilb-packet-mirroring \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --load-balancing-scheme=internal \
        --network=packet-mirror-vpc \
        --subnet=collectors \
        --ip-protocol=TCP \
        --ports=all \
        --backend-service=collector-ilb \
        --backend-service-region="$TF_VAR_region" \
        --is-mirroring-collector
    

    L'output è simile al seguente:

    ...
    Created [https://www.googleapis.com/compute/v1/projects/pm-pid-1357261223/regions/us-west1/backendServices/collector-ilb].
    NAME           BACKENDS  PROTOCOL
    collector-ilb            TCP
    ...
    Updated [https://www.googleapis.com/compute/v1/projects/pm-pid-1357261223/regions/us-west1/backendServices/collector-ilb].
    ...
    Created [https://www.googleapis.com/compute/projects/pm-pid-1357261223/regions/us-west1/forwardingRules/fr-ilb-packet-mirroring].
    ...
    

Crea e disattiva il criterio di Mirroring pacchetto

  1. In Cloud Shell, crea e disattiva un criterio di Mirroring pacchetto:

    gcloud compute packet-mirrorings create pm-mirror-subnet1 \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --network=packet-mirror-vpc \
        --collector-ilb=fr-ilb-packet-mirroring \
        --mirrored-subnets=webservers \
        --no-enable
    
    gcloud compute packet-mirrorings describe pm-mirror-subnet1 \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region"
    

    L'output è simile al seguente:

    ...
    Created [https://www.googleapis.com/compute/projects/pm-pid-1357261223/regions/us-west1/packetMirrorings/pm-mirror-subnet1].
    ...
    collectorIlb:
    ...
    enable: 'FALSE'
    ...
    

    Il criterio di Mirroring pacchetto è attivo per impostazione predefinita. In questo passaggio devi disabilitare il criterio perché vuoi che il mirroring del pacchetto sia disattivato fino a quando Cloud Logging non rileva un problema.

Crea automazione per attivare il mirroring pacchetto

  1. In Cloud Shell, crea l'argomento Pub/Sub che utilizzi per il sink di Cloud Logging:

    gcloud pubsub topics create stackdriver_logging \
        --project="$TF_VAR_pid"
    

    L'output è simile al seguente:

    ...
    Created topic [projects/pm-pid-1357261223/topics/stackdriver_logging].
    ...
    
  2. Crea un sink di Cloud Logging:

    gcloud logging sinks create stackdriver_logging pubsub.googleapis.com/projects/"$TF_VAR_pid"/topics/stackdriver_logging \
        --log-filter='resource.type="http_load_balancer" \
            AND http_request.status>=500' \
        --project=$TF_VAR_pid
    

    Il sink di Cloud Logging filtra i codici di stato HTTP globali nell'intervallo 500 (ad esempio 500, 501 o 502) e invia gli eventi all'argomento Pub/Sub.

    L'output è simile al seguente:

    Created [https://logging.googleapis.com/v2/projects/pm-pid-1357261223/sinks/stackdriver_logging].
    Please remember to grant `serviceAccount:p422429379846-984011@gcp-sa-logging.iam.gserviceaccount.com` the Pub/Sub Publisher role on the topic.
    More information about sinks can be found at https://cloud.oogle.com/logging/docs/export/configure_export
    

    Copia il valore serviceAccount dall'output. Questo valore è necessario nel passaggio successivo.

  3. Concedi all'account di servizio il ruolo IAM Publisher Pub/Sub (roles/pubsub.publisher):

    gcloud pubsub topics add-iam-policy-binding stackdriver_logging \
        --project="$TF_VAR_pid" \
        --member serviceAccount:UPDATE_ACCOUNT \
        --role roles/pubsub.publisher
    

    Sostituisci UPDATE_ACCOUNT con il valore relativo a serviceAccount nel passaggio precedente.

    L'output è simile al seguente:

    ...
    Updated IAM policy for topic [stackdriver_logging].
    bindings:
    - members:
      - serviceAccount:UPDATE_ACCOUNT
      role: roles/pubsub.publisher
    etag: notuCRmpoyI=
    version: 1
    ...
    
  4. Aggiorna il file main.py:

    net_id="$(gcloud compute networks describe packet-mirror-vpc --project="$TF_VAR_pid" --format='value(id)')"
    sed -i "s/PROJECT-ID/"$TF_VAR_pid"/g" main.py
    sed -i "s/REGION/"$TF_VAR_region"/g" main.py
    sed -i "s/NETWORK-ID/"$net_id"/g" main.py
    

    Il file main.py nel repository contiene la funzione packet_mirror_pubsub che utilizzerai per creare la funzione Cloud Functions. Prima di creare la funzione Cloud Functions, il comando precedente aggiorna le informazioni sull'ID progetto, sull'area geografica e sulla rete Google Cloud nel file Python.

  5. Crea la funzione Cloud Functions:

    gcloud functions deploy packet_mirror_pubsub \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --runtime python37 \
        --trigger-topic stackdriver_logging
    

    Se viene visualizzato il seguente avviso, inserisci N:

    Allow unauthenticated invocations of new function
    [packet_mirror_pubsub]? (y/N)?
    

    L'output è simile al seguente:

    ...
    availableMemoryMb: 256
    entryPoint: packet_mirror_pubsub
    eventTrigger:
      eventType: google.pubsub.topic.publish
      failurePolicy: {}
      resource: projects/pm-pid--1517226903/topics/stackdriver_logging
      service: pubsub.googleapis.com
    ingressSettings: ALLOW_ALL
    labels:
      deployment-tool: cli-gcloud
    name: projects/pm-pid--1517226903/locations/europe-west1/functions/packet_mirror_pubsub
    runtime: python37
    serviceAccountEmail: pm-pid--1517226903@appspot.gserviceaccount.com
    ...
    status: ACTIVE
    ...
    

    Il deployment della funzione Cloud Functions può richiedere diversi minuti.

  6. Se ricevi un messaggio di errore, procedi nel seguente modo:

    • Se ricevi un errore di abilitazione dell'API Cloud Build, abilita l'API:

      gcloud services enable cloudbuild.googleapis.com
      

      Riprova il passaggio 5.

    • Se ricevi un messaggio di errore relativo all'accesso a Cloud Storage, prova nuovamente il passaggio 5. Questo errore può verificarsi quando esegui i comandi in rapida successione.

Verifica della soluzione

Nei passaggi di seguito, puoi attivare e verificare la soluzione.

  1. In Cloud Shell, convalida il nuovo abbonamento Pub/Sub:

    gcloud pubsub subscriptions list --project="$TF_VAR_pid"
    

    L'output è simile al seguente:

    ...
    ---
    ackDeadlineSeconds: 600
    expirationPolicy: {}
    messageRetentionDuration: 604800s
    name: projects/pm-pid--1517226903/subscriptions/gcf-packet_mirror_pubsub-europe-west1-stackdriver_logging
    pushConfig:
      attributes:
        x-goog-version: v1
      pushEndpoint: https://e147a3acbd9a5314f553d1710671be9c-dot-efdbf9529ce1147d5p-tp.appspot.com/_ah/push-handlers/pubsub/projects/pm-pid--1517226903/topics/stackdriver_logging?pubsub_trigger=true
    topic: projects/pm-pid--1517226903/topics/stackdriver_logging
    ...
    
  2. Accedi alla VM del raccoglitore:

    gcloud compute ssh collector \
        --tunnel-through-iap \
        --project="$TF_VAR_pid" \
        --zone="$TF_VAR_zone"
    
  3. Dopo aver eseguito l'accesso alla VM del raccoglitore, installa e abilita l'utilità tcpdump:

    sudo apt-get install tcpdump -y
    sudo tcpdump -n not net 172.16.21.0/24
    

    L'output è simile al seguente:

    tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
    listening on eth0, link-type EN10MB (Ethernet), capture size 262144 bytes
    

    Lascia aperta questa sessione di Cloud Shell.

  4. Apri una nuova finestra del terminale Cloud Shell, quindi attiva la funzione Cloud Functions generando un errore HTTP 500:

    cd $HOME/packetMirror
    source TF_ENV_VARS
    lb_ip=$(gcloud compute forwarding-rules describe packet-mirror-gfr --project=$TF_VAR_pid --global --format="value(IPAddress)")
    curl http://"$lb_ip"/error500
    

    L'output è simile al seguente:

    <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
    <html><head>
    <title>500 Internal Server Error</title>
    </head><body>
    <h1>Internal Server Error</h1>
    <p>The server encountered an internal error or
    misconfiguration and was unable to complete
    your request.</p>
    <p>Please contact the server administrator at
     webmaster@localhost to inform them of the time this error occurred,
     and the actions you performed just before this error.</p>
    <p>More information about this error may be available
    in the server error log.</p>
    <hr>
    <address>Apache/2.4.25 (Debian) Server at 35.241.40.217 Port 80</address>
    
  5. Torna alla sessione Cloud Shell per la VM del raccoglitore e osserva l'output dal comando tcpdump. La VM del raccoglitore riceve traffico, che è il probe del controllo di integrità sulle istanze del server web.

    L'output è simile al seguente:

    ...
    07:33:41.131992 IP 130.211.2.146.53702 > 172.16.20.2.80: Flags [S], seq 4226031116, win 65535, options [mss 1420,sackOK,TS val 2961711820 ecr 0,nop,wscale 8], length 0
    07:33:41.132149 IP 130.211.2.146.53702 > 172.16.20.2.80: Flags [.], ack 3978158577, win 256, options [nop,nop,TS val 2961711821 ecr 4348156], length 0
    ...
    
  6. Per interrompere l'output del comando tcpdump, premi Control+C.

  7. Digita exit per uscire dalla VM del raccoglitore.

  8. In Cloud Shell, controlla i log per verificare che la funzione Cloud Functions sia stata eseguita:

    gcloud functions logs read \
        --limit 50 \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region"
    

    L'output è simile al seguente:

    LEVEL  NAME                  EXECUTION_ID     TIME_UTC                 LOG
    D      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:39.206  Function execution started
    I      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:39.222  HTTP 500 Error Detected in: {"httpRequest":{"remoteIp":"136.27.39.107","requestMethod":"GET","requestSize":"85","requestUrl":"http://35.241.40.217/error500","responseSize":"801","serverIp":"172.16.20.2","status":500,"userAgent":"curl/7.52.1"},"insertId":"nb4g1sfdrpm04","jsonPayload":{"@type":"type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry","enforcedSecurityPolicy":{"configuredAction":"ACCEPT","name":"policy","outcome":"ACCEPT","priority":2147483647},"statusDetails":"response_sent_by_backend"},".............
    I      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:39.222  Activating Packet Mirroring For Analysis
    I      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:39.329  ya29.c.KqUBvwfoZ5z88EmHKPXkgd1Gwqwwca88wWsyqjxrEFdhK8HjJDwmBWBIX_DAnC4wOO5W2B6EOQArgHQ03AIVwFnQMawXrB2tLGIkBYFuP3Go5Fylo6zZAvgtXF3LvrXiarwaASkfAM73lXfQiT20PYn4ML4E2Kli9WmhZDu6AdAe1aH-FK2MEoca84zgG65tirRGe04EJGY_hYHejlG_xrRWeaojVlc3
    I      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:40.100  {
    I      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:40.100    "id": "1924200601229605180",
    I      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:40.100    "name": "operation-1582270419413-59f110a49a878-b68f2d26-c8f66a7b",
    I      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:40.100    "operationType": "patch",
    I      packet_mirror_pubsub  999875368753102  2020-02-21 07:33:40.100    …..
     Function execution took 900 ms, finished with status: 'ok'
    

    I log mostrano che il mirroring del pacchetto è stato attivato in base al codice di errore HTTP 500 generato dalle istanze del server web.

  9. Convalida lo stato della funzionalità di mirroring dei pacchetti:

    gcloud compute packet-mirrorings describe pm-mirror-subnet1 \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region"
    

    L'output è simile al seguente:

    ...
    collectorIlb:
    ...
    enable: 'TRUE'
    ...
    

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial.

Elimina l'infrastruttura

  1. In Cloud Shell, rimuovi le risorse di automazione:

    gcloud functions delete packet_mirror_pubsub \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --quiet
    gcloud logging sinks delete stackdriver_logging \
        --project="$TF_VAR_pid" \
        --quiet
    gcloud pubsub topics delete stackdriver_logging \
        --project="$TF_VAR_pid" \
        --quiet
    gcloud compute packet-mirrorings delete  pm-mirror-subnet1  \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --quiet
    gcloud compute forwarding-rules delete fr-ilb-packet-mirroring \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --quiet
    gcloud compute backend-services delete collector-ilb \
        --project="$TF_VAR_pid" \
        --region="$TF_VAR_region" \
        --quiet
    
  2. Elimina tutti i componenti del tutorial:

    pushd $HOME/packetMirror
    terraform destroy
    popd
    

    Quando ti viene richiesto, inserisci yes per eliminare la configurazione.

  3. Rimuovi il repository Git:

    rm -rf $HOME/packetMirror
    

Passaggi successivi