Configura i criteri di autorizzazione per i bilanciatori del carico delle applicazioni

Nei bilanciatori del carico delle applicazioni, i criteri di autorizzazione vengono richiamati dopo la valutazione estensioni di routing, criteri di sicurezza di rete (valutati da Google Cloud Armor), criteri di condivisione delle risorse tra origini (CORS) e Identity-Aware Proxy (IAP), ma prima di eseguire azioni di gestione del traffico.

Questa pagina mostra come configurare i criteri di autorizzazione per i bilanciatori del carico delle applicazioni.

Prima di iniziare

configura il bilanciatore del carico

Se non hai creato un bilanciatore del carico, consulta le seguenti pagine per configurare il bilanciatore del carico delle applicazioni che preferisci:

Crea e configura tag o account di servizio sicuri

Con i bilanciatori del carico delle applicazioni interni, puoi applicare facoltativamente criteri di autorizzazione in base ai tag sicuri e agli account di servizio associati alle VM client. Se hai intenzione di applicare criteri di autorizzazione basati su tag, usare Resource Manager per creare i tag.

Se utilizzi bilanciatori del carico delle applicazioni esterni, non devi creare e configurare i tag sicuri.

Per ulteriori informazioni, vedi Utilizzare i tag per i firewall e Account di servizio.

Collega gli account di servizio alle VM client

Per informazioni dettagliate sull'associazione di un account di servizio a un'istanza VM, consulta i seguenti documenti:

Crea le chiavi e i valori dei tag protetti

Prima di associare tag sicuri al modello di gruppo di istanze, crea la proteggere le chiavi e i valori dei tag e designarli allo scopo di GCE_FIREWALL. È necessario per le funzionalità di networking di Google Cloud, incluso Secure Web Proxy e i criteri di autorizzazione.

Per creare tag sicuri, devi disporre del ruolo Amministratore del tag (roles/resourcemanager.tagAdmin).

Console

  1. Nella console Google Cloud, vai alla pagina Tag.

    Vai a Tag

  2. Fai clic su Crea.

  3. Inserisci una descrizione nel campo Descrizione chiave tag.

  4. Seleziona la casella di controllo Da utilizzare con il firewall di rete.

  5. Nell'elenco Progetto, seleziona il progetto Google Cloud in cui vuoi creare il tag.

  6. Nel campo Rete, seleziona LB_NETWORK.

  7. Fai clic su Aggiungi valore.

  8. Nel campo Valore tag, inserisci TAG_VALUE. Il valore deve essere numerico.

  9. Nel campo Descrizione valore tag, inserisci una descrizione.

  10. Quando hai finito di aggiungere i valori dei tag, fai clic su Crea chiave tag.

gcloud

  1. Crea la chiave tag sicuro.

    gcloud resource-manager tags keys create TAG_KEY \
    --parent=organizations/ORG_ID \
    --purpose=GCE_FIREWALL \
    --purpose-data=network=LB_NETWORK

    Sostituisci quanto segue:

    • TAG_KEY: il nome della chiave del tag sicuro.
    • ORG_ID: l'ID della tua organizzazione.
    • LB_NETWORK: il nome della rete VPC.

  2. Aggiungi il valore del tag sicuro alla chiave del tag numerico.

    gcloud resource-manager tags values create TAG_VALUE \
    --parent=ORG_ID/TAG_KEY

    Sostituisci TAG_VALUE con un valore del tag numerico.

Collega il tag sicuro al modello di gruppo di istanze

Gli amministratori dei tag possono associare i tag sicuri a singole istanze VM o al modello di gruppo di istanze e collegare il valore del tag ai backend delle VM o del modello.

Per associare tag protetti, è necessario il campo Utente tag ruolo (roles/resourcemanager.tagUser).

  1. Definisci il prefisso del nome completo per il progetto e la zona:

    FULL_NAME_PREFIX=//compute.googleapis.com/projects/PROJECT_ID/zones/ZONE/instances/

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del progetto.
    • ZONE: la zona in cui si trova il gruppo di istanze gestite.

  2. Ottieni l'ID modello di gruppo di istanze:

    TEMPLATE_ID=$(gcloud compute instance-templates describe TEMPLATE_NAME --region=LOCATION --format='value(id)')

    Sostituisci quanto segue:

    • TEMPLATE_NAME: il nome del modello di gruppo di istanze.
    • LOCATION: la regione Google Cloud.

  3. Concatena i valori di FULL_NAME_PREFIX e TEMPLATE_ID:

    PARENT="$FULL_NAME_PREFIX$TEMPLATE_ID"
echo $PARENT

  4. Crea le associazioni.

    gcloud resource-manager tags bindings create \
    --location LOCATION \
    --tag-value ORG_ID/TAG_KEY/TAG_VALUE \
    --parent PARENT

    Sostituisci quanto segue:

    • ORG_ID: l'ID della tua organizzazione.
    • LOCATION: la tua regione Google Cloud.
    • TAG_KEY: il nome della chiave del tag sicuro.
    • TAG_VALUE: il valore numerico del tag.

Crea il criterio di autorizzazione

Per creare un criterio di autorizzazione, devi creare un file YAML che definisce il target e le regole, quindi importarlo utilizzando il comando gcloud beta network-security authz-policies.

Criterio di autorizzazione per rifiutare le richieste

Globali e interregionali

Se utilizzi un bilanciatore del carico delle applicazioni esterno globale o un bilanciatore del carico delle applicazioni interno tra regioni, segui questi passaggi per creare e importare il criterio di autorizzazione:

  1. Creare il file dei criteri di autorizzazione per rifiutare determinate richieste.

    Nell'esempio seguente viene creato un file authz-policy-deny.yaml per l'inoltro regola LB_FORWARDING_RULE in località global. Le norme nega ai client di *.hello.com di accedere all'URL /api/payments del tuo percorso di apprendimento.

    $ cat >authz-policy-deny.yaml <<EOF
name: my-authz-policy-deny
target:
  loadBalancingScheme: LB_SCHEME
  resources:
  - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules/LB_FORWARDING_RULE"
httpRules:
- from:
    sources:
    - principals:
      - suffix: ".hello.com"
  to:
    operations:
    - paths:
      - prefix: "/api/payments"
action: DENY
EOF

    Sostituisci quanto segue:

    • LB_SCHEME: lo schema di bilanciamento del carico. Per il bilanciatore del carico delle applicazioni esterno globale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno tra regioni, imposta lo schema su INTERNAL_MANAGED.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Crea il criterio di autorizzazione e importa il file YAML.

    Il comando di esempio seguente importa il file dei criteri creato in precedenza e crea i criteri di autorizzazione:

    gcloud beta network-security authz-policies import my-authz-policy-deny \
    --source=authz-policy-deny.yaml \
    --location=global

Regionale

Se usi un bilanciatore del carico delle applicazioni esterno regionale o un bilanciatore del carico delle applicazioni interno regionale, segui questi passaggi per creare e importare il criterio di autorizzazione:

  1. Creare il file dei criteri di autorizzazione per consentire determinate richieste.

    L'esempio seguente crea un file authz-policy-deny.yaml per la regola di inoltro LB_FORWARDING_RULE in una regione Google Cloud. Il criterio nega ai client con identità corrispondenti a *.hello.com di accedere al percorso URL/api/payments. Il criterio nega anche l'accesso a qualsiasi VM client con l'account di servizio my-sa-123@PROJECT_ID.iam.gserviceaccount.com all'URL /api/payments.

    $ cat >authz-policy-deny.yaml <<EOF
name: my-authz-policy-deny
target:
  loadBalancingScheme: LB_SCHEME
  resources:
  - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/LOCATION/forwardingRules/LB_FORWARDING_RULE"
httpRules:
- from:
    sources:
    - principals:
      - suffix: ".hello.com"
  to:
    operations:
    - paths:
      - prefix: "/api/payments"
- from:
    sources:
    - resources:
       - iamServiceAccount:
           exact: "my-sa-123@PROJECT_ID.iam.gserviceaccount.com"
  to:
    operations:
    - paths:
      - prefix: "/api/payments"
action: DENY
EOF

    Sostituisci quanto segue:

    • LB_SCHEME: schema di bilanciamento del carico. Per il bilanciatore del carico delle applicazioni esterno regionale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • LOCATION: la tua regione Google Cloud.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Creare il criterio di autorizzazione e importare il file YAML.

    Il seguente comando di esempio importa il file di criteri creato in precedenza e crea i criteri di autorizzazione nella regione LOCATION:

    gcloud beta network-security authz-policies import my-authz-policy-deny \
    --source=authz-policy-deny.yaml \
    --location=LOCATION

Criterio di autorizzazione per consentire le richieste

Globali e interregionali

Se utilizzi un bilanciatore del carico delle applicazioni esterno globale o un bilanciatore del carico delle applicazioni interno tra regioni, segui questi passaggi per creare e importare il criterio di autorizzazione:

  1. Crea il file del criterio di autorizzazione per consentire determinate richieste.

    Nell'esempio seguente viene creato un file authz-policy-allow.yaml per l'inoltro regola LB_FORWARDING_RULE in località global. Il criterio consente solo ai client del dominio *.example.com di accedere all'account Percorso dell'URL /api/payments.

    $ cat >authz-policy-allow.yaml <<EOF
name: my-authz-policy-allow
target:
  loadBalancingScheme: LB_SCHEME
  resources:
  - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules/LB_FORWARDING_RULE"
httpRules:
- from:
  sources:
  - principals:
    - suffix: ".example.com"
  to:
    operations:
    - paths:
      - exact: "/api/payments"
action: ALLOW
EOF

    Sostituisci quanto segue:

    • LB_SCHEME: lo schema di bilanciamento del carico. Per il bilanciatore del carico delle applicazioni esterno globale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno tra regioni, imposta lo schema su INTERNAL_MANAGED.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Crea il criterio di autorizzazione e importa il file YAML.

    Il comando di esempio seguente importa il file dei criteri creato in precedenza e crea i criteri di autorizzazione:

    gcloud beta network-security authz-policies import my-authz-policy-allow \
    --source=authz-policy-allow.yaml \
    --location=global

Regionale

Se usi un bilanciatore del carico delle applicazioni esterno regionale o un bilanciatore del carico delle applicazioni interno regionale, segui questi passaggi per creare e importare il criterio di autorizzazione:

  1. Creare il file dei criteri di autorizzazione per consentire determinate richieste.

    L'esempio seguente crea un file authz-policy-allow.yaml per la regola di inoltro LB_FORWARDING_RULE in una regione Google Cloud di un bilanciatore del carico delle applicazioni interno regionale. Il criterio consente solo ai client del dominio *.example.com di accedere all'account Percorso URL /api/payments quando la richiesta proviene da una VM con il tag risorsa TAG_VALUE.

    $ cat >authz-policy-allow.yaml <<EOF
name: my-authz-policy-allow
target:
  loadBalancingScheme: LB_SCHEME
  resources:
  - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/LOCATION/forwardingRules/LB_FORWARDING_RULE"
httpRules:
- from:
  sources:
  - principals:
    - suffix: ".example.com"
    resources:
    - tagValueIdSet:
      - ids: "TAG_VALUE"
  to:
    operations:
    - paths:
      - exact: "/api/payments"
action: ALLOW
EOF

    Sostituisci quanto segue:

    • LB_SCHEME: lo schema di bilanciamento del carico. Se utilizzi un bilanciatore del carico delle applicazioni esterno regionale, imposta lo schema su EXTERNAL_MANAGED. Se utilizzi il bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • LOCATION: la tua regione Google Cloud.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Creare il criterio di autorizzazione e importare il file YAML.

    Il seguente comando di esempio importa il file di criteri creato in precedenza e crea i criteri di autorizzazione nella regione LOCATION:

    gcloud beta network-security authz-policies import my-authz-policy-allow \
    --source=authz-policy-allow.yaml \
    --location=LOCATION

Criterio di autorizzazione per delegare a un'estensione di servizio

Prima di iniziare, configura un motore di autorizzazione esterno. Per saperne di più sulle estensioni di servizio, consulta la panoramica dei callout di Cloud Load Balancing.

Globali e interregionali

Se usi un bilanciatore del carico delle applicazioni esterno globale o un bilanciatore del carico delle applicazioni interno tra regioni, segui questi passaggi per creare e importare il criterio di autorizzazione:

  1. Crea il file del criterio di autorizzazione per delegare determinate richieste a un servizio esterno.

    L'esempio seguente crea un file authz-policy-custom.yaml per la regola di forwarding LB_FORWARDING_RULE nella posizione global. Il criterio chiama l'estensione AUTHZ_EXTENSION per tutto il traffico verso il percorso dell'URL /api/payments quando la richiesta contiene un'intestazione Authorization non vuota.

    $ cat >authz-policy-custom.yaml <<EOF
name: my-authz-policy-custom
target:
  loadBalancingScheme: LB_SCHEME
  resources:
  - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules/LB_FORWARDING_RULE"
httpRules:
- to:
    operations:
    - paths:
      - exact: "/api/payments"
  when: 'request.headers["Authorization"] != ""'
action: CUSTOM
customProvider:
  authzExtension:
    resources:
    - "https://networkservices.googleapis.com/v1/projects/PROJECT_ID/locations/global/authzExtensions/AUTHZ_EXTENSION"
EOF

    Sostituisci quanto segue:

    • LB_SCHEME: lo schema di bilanciamento del carico. Per il bilanciatore del carico delle applicazioni esterno globale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno tra regioni, imposta lo schema su INTERNAL_MANAGED.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.
    • AUTHZ_EXTENSION: il nome dell'estensione di autorizzazione.

  2. Crea il criterio di autorizzazione e importa il file YAML.

    Il comando di esempio seguente importa il file dei criteri creato in precedenza e crea i criteri di autorizzazione:

    gcloud beta network-security authz-policies import my-authz-policy-custom \
    --source=authz-policy-custom.yaml \
    --location=global

Regionale

Se utilizzi un bilanciatore del carico delle applicazioni esterno regionale o un bilanciatore del carico delle applicazioni interno regionale, segui questi passaggi per creare e importare il criterio di autorizzazione:

  1. Creare il file dei criteri di autorizzazione per delegare determinate richieste a un servizio esterno.

    Nell'esempio seguente viene creato un file authz-policy-custom.yaml per l'inoltro regola LB_FORWARDING_RULE in una regione Google Cloud di un bilanciatore del carico delle applicazioni interno regionale. Il criterio chiama l'estensione AUTHZ_EXTENSION per tutto il traffico verso il percorso dell'URL /api/payments quando la richiesta contiene un'intestazione Authorization non vuota.

    $ cat >authz-policy-custom.yaml <<EOF
name: my-authz-policy-custom
target:
  loadBalancingScheme: LB_SCHEME
  resources:
  - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/LOCATION/forwardingRules/LB_FORWARDING_RULE"
httpRules:
- to:
    operations:
    - paths:
      - exact: "/api/payments"
  when: 'request.headers["Authorization"] != ""'
action: CUSTOM
customProvider:
  authzExtension:
    resources:
    - "https://networkservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/authzExtensions/AUTHZ_EXTENSION"
EOF

    Sostituisci quanto segue:

    • LB_SCHEME: schema di bilanciamento del carico. Per il bilanciatore del carico delle applicazioni esterno regionale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • LOCATION: la tua regione Google Cloud.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.
    • AUTHZ_EXTENSION: il nome dell'estensione di autorizzazione.

  2. Crea il criterio di autorizzazione e importa il file YAML.

    Il comando di esempio seguente importa il file dei criteri creato in precedenza e crea i criteri di autorizzazione nella regione LOCATION:

    gcloud beta network-security authz-policies import my-authz-policy-custom \
    --source=authz-policy-custom.yaml \
    --location=LOCATION

Testa i criteri di autorizzazione

Per testare i criteri di autorizzazione, invia del traffico al bilanciatore del carico. Per ulteriori informazioni, consulta le pagine seguenti:

Informazioni sui log dei criteri di autorizzazione in Cloud Logging

Per capire in che modo i criteri di autorizzazione vengono registrati quando una richiesta viene consentita o rifiutata, consulta quanto segue:

  • Quando una richiesta non corrisponde ai criteri ALLOW o DENY, il criterio DENY lo consente e lo registra come allowed_as_no_allow_policies_matched_request. Tuttavia, il criterio ALLOW la nega e la registra come denied_as_no_allow_policies_matched_request. Poiché uno dei criteri rifiuta la richiesta, la richiesta viene rifiutata.

    Se utilizzi un bilanciatore del carico delle applicazioni esterno globale, statusDetails è impostato su denied_by_authz_policy nel log. Vedi il seguente esempio:

      {
    httpRequest: {8}
    insertId: "example-id"
    jsonPayload: {
      @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
      authzPolicyInfo: {
        policies: [
          0: {
            details: "allowed_as_no_deny_policies_matched_request"
            result: "ALLOWED"
          }
          1: {
            details: "denied_as_no_allow_policies_matched_request"
            result: "DENIED"
          }
        ]
        result: "DENIED"
      }
      backendTargetProjectNumber: "projects/12345567"
      remoteIp: "00.100.11.104"
      proxyStatus: "error=\"http_request_error\"; details=\"denied_by_authz_policy\""
    }
    logName: "projects/example-project/logs/requests"
    receiveTimestamp: "2024-08-28T15:33:56.046651035Z"
    resource: {2}
    severity: "WARNING"
    spanId: "3e1a09a8e5e3e14d"
    timestamp: "2024-08-28T15:33:55.355042Z"
    trace: "projects/example-project/traces/8c8b3dbf9a19c85954d0fa2d958ca509"
  }

    Se utilizzi un bilanciatore del carico delle applicazioni interno regionale, un bilanciatore del carico delle applicazioni esterno regionale o un bilanciatore del carico delle applicazioni interno tra regioni, proxyStatus è impostato su error=\"http_request_error\"; details=\"denied_by_authz_policy\" nel log. Vedi il seguente esempio:

      {
    httpRequest: {8}
    insertId: "example-id"
    jsonPayload: {
      @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
      authzPolicyInfo: {
        policies: [
          0: {
            details: "allowed_as_no_deny_policies_matched_request"
            result: "ALLOWED"
          }
          1: {
            details: "denied_as_no_allow_policies_matched_request"
            result: "DENIED"
          }
        ]
        result: "DENIED"
      }
      backendTargetProjectNumber: "projects/12345567"
      remoteIp: "00.100.11.104"
      proxyStatus: "error=\"http_request_error\"; details=\"denied_by_authz_policy\""
    }
    logName: "projects/example-project/logs/requests"
    receiveTimestamp: "2024-08-28T15:33:56.046651035Z"
    resource: {2}
    severity: "WARNING"
    spanId: "3e1a09a8e5e3e14d"
    timestamp: "2024-08-28T15:33:55.355042Z"
    trace: "projects/example-project/traces/8c8b3dbf9a19c85954d0fa2d958ca509"
  }

    • Quando una richiesta corrisponde al criterio DENY, viene rifiutata e il criterio che ha rifiutato la richiesta viene registrato.

      Se utilizzi un bilanciatore del carico delle applicazioni esterno globale, statusDetails è impostato su denied_by_authz_policy nel log. Il nome del criterio che ha rifiutato la richiesta viene registrato in policies. Vedi il seguente esempio:

      {
  httpRequest: {8}
  insertId: "example-id"
  jsonPayload: {
    @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
    authzPolicyInfo: {
      policies: [
        0: {
          details: "name: "projects/12345567/locations/global/authzPolicies/deny-authz-policy-test""
          result: "DENIED"
        }
      ]
      result: "DENIED"
    }
    backendTargetProjectNumber: "projects/12345567"
    cacheDecision: [2]
    remoteIp: "00.100.11.104"
    statusDetails: "denied_by_authz_policy"
  }
  logName: "projects/example-project/logs/requests"
  receiveTimestamp: "2024-08-28T15:33:56.046651035Z"
  resource: {2}
  severity: "WARNING"
  spanId: "3e1a09a8e5e3e14d"
  timestamp: "2024-08-28T15:33:55.355042Z"
  trace: "projects/example-project/traces/8c8b3dbf9a19c85954d0fa2d958ca509"
}

      Se utilizzi un bilanciatore del carico delle applicazioni interno regionale, un bilanciatore del carico delle applicazioni esterno regionale o il bilanciatore del carico delle applicazioni interno tra regioni, proxyStatus è impostato su error=\"http_request_error\"; details=\"denied_by_authz_policy\", mentre il nome del criterio viene registrato in policies. Vedi il seguente esempio:

      {
  httpRequest: {8}
  insertId: "example-id"
  jsonPayload: {
    @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
    authzPolicyInfo: {
      policies: [
        0: {
          details: "name: "projects/12345567/locations/$REGION/authzPolicies/deny-authz-policy-test""
          result: "DENIED"
        }
      ]
      result: "DENIED"
    }
    backendTargetProjectNumber: "projects/12345567"
    remoteIp: "00.100.11.104"
    proxyStatus: "error=\"http_request_error\"; details=\"denied_by_authz_policy\""
  }
  logName: "projects/example-project/logs/requests"
  receiveTimestamp: "2024-08-28T15:33:56.046651035Z"
  resource: {2}
  severity: "WARNING"
  spanId: "3e1a09a8e5e3e14d"
  timestamp: "2024-08-28T15:33:55.355042Z"
  trace: "projects/example-project/traces/8c8b3dbf9a19c85954d0fa2d958ca509"
}

    • Quando una richiesta non corrisponde al criterio DENY, ma corrisponde al criterio ALLOW, la richiesta è consentita. Nel log, l'azione viene registrata come allowed_as_no_deny_policies_matched_request per il criterio DENY. Viene registrato anche il criterio che ha consentito la richiesta.

      Se utilizzi un bilanciatore del carico delle applicazioni esterno globale, nel log non sarà presente statusDetails. Il criterio che ha consentito la richiesta è stato registrato anche in policies. Vedi il seguente esempio:

      {
  httpRequest: {8}
  insertId: "example-id"
  jsonPayload: {
    @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
    authzPolicyInfo: {
      policies: [
        0: {
          details: "allowed_as_no_deny_policies_matched_request"
          result: "ALLOWED"
        }
        1: {
          details: "name: "projects/12345567/locations/global/authzPolicies/allow-authz-policy-test""
          result: "ALLOWED"
        }
      ]
      result: "ALLOWED"
    }
    backendTargetProjectNumber: "projects/12345567"
    cacheDecision: [2]
    remoteIp: "00.100.11.104"
  }
  logName: "projects/example-project/logs/requests"
  receiveTimestamp: "2024-08-28T15:33:56.046651035Z"
  resource: {2}
  severity: "WARNING"
  spanId: "3e1a09a8e5e3e14d"
  timestamp: "2024-08-28T15:33:55.355042Z"
  trace: "projects/example-project/traces/8c8b3dbf9a19c85954d0fa2d958ca509"
}

    • Se utilizzi un bilanciatore del carico delle applicazioni interno regionale, un bilanciatore del carico delle applicazioni esterno regionale o bilanciatore del carico delle applicazioni interno tra regioni, nel log non è presente un campo proxyStatus. Il criterio che ha consentito la richiesta è registrato anche in policies. Vedi l'esempio di seguito:

      {
  httpRequest: {8}
  insertId: "example-id"
  jsonPayload: {
    @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
    authzPolicyInfo: {
      policies: [
        0: {
          details: "allowed_as_no_deny_policies_matched_request"
          result: "ALLOWED"
        }
        1: {
          details: "name: "projects/12345567/locations/$REGION/authzPolicies/allow-authz-policy-test""
          result: "ALLOWED"
        }
      ]
      result: "ALLOWED"
    }
    backendTargetProjectNumber: "projects/12345567"
    cacheDecision: [2]
    remoteIp: "00.100.11.104"
  }
  logName: "projects/example-project/logs/requests"
  receiveTimestamp: "2024-08-28T15:33:56.046651035Z"
  resource: {2}
  severity: "WARNING"
  spanId: "3e1a09a8e5e3e14d"
  timestamp: "2024-08-28T15:33:55.355042Z"
  trace: "projects/example-project/traces/8c8b3dbf9a19c85954d0fa2d958ca509"
}

Passaggi successivi