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

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 collega service account o tag alle VM Google Cloud

Per i bilanciatori del carico delle applicazioni interni, puoi applicare policy di autorizzazione in base agli account di servizio o ai tag collegati a risorse diverse Google Cloud.

L'esempio in questo documento fornisce istruzioni per creare un criterio di autorizzazione basato su service account o tag collegati a istanze di macchina virtuale (VM) Google Cloud . Qualsiasi richiesta proveniente da una VM client collegata a un account di servizio o a un tag specifico può essere consentita, negata o delegata a un servizio esterno. Un esempio di questo criterio di autorizzazione che utilizza service account e tag per applicare controllo dell'accesso è fornito nella sezione Criterio di autorizzazione basato su service account o tag di questo documento.

L'applicazione di criteri di autorizzazione basati su service account o tag non è supportata per i bilanciatori del carico delle applicazioni esterni.

Collega service account alle VM client

Per istruzioni su come collegare un account di servizio a un'istanza VM, consulta i seguenti documenti:

Allegare tag al modello di gruppo di istanze

Prima di associare un tag al modello di gruppo di istanze, devi creare una chiave e un valore del tag. Quando crei un tag, assegnagli uno scopo GCE_FIREWALL.Le funzionalità di networking, tra cui Secure Web Proxy e i criteri di autorizzazione, richiedono lo scopo GCE_FIREWALL per applicare il tag. Google Cloud

Crea una chiave e un valore del tag

Per creare tag, 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. Nel campo Descrizione chiave tag, inserisci una descrizione.

  4. Seleziona la casella di controllo Per l'utilizzo con un 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 del valore del tag, inserisci una descrizione.

  10. Al termine dell'aggiunta dei valori dei tag, fai clic su Crea chiave tag.

gcloud

  1. Crea la chiave tag.

    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.
    • ORG_ID: l'ID della tua organizzazione.
    • LB_NETWORK: il nome della tua rete VPC.

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

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

    Sostituisci TAG_VALUE con un valore numerico del tag.

Associa il tag al modello di gruppo di istanze

Gli amministratori dei tag possono associare i tag 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 i tag, devi disporre del ruolo Utente tag (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 progetto.
    • ZONE: la zona in cui si trova il gruppo di istanze gestite.

  2. Ottieni l'ID del 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 tua Google Cloud regione.

  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 Google Cloud regione.
    • TAG_KEY: il nome della chiave tag sicura.
    • TAG_VALUE: il valore numerico del tag.

Crea un criterio di autorizzazione

Per creare una policy di autorizzazione, crea un file YAML che definisce la destinazione e le regole, quindi importa il file utilizzando il comando gcloud beta network-security authz-policies.

Questa sezione fornisce istruzioni per creare diversi tipi di criteri di autorizzazione collegati alla regola di forwarding di un bilanciatore del carico.

Policy di autorizzazione per negare le richieste

Questa sezione fornisce un esempio di policy di autorizzazione che nega le richieste in base ai principal del certificato client.

Globale e interregionale

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 un criterio di autorizzazione:

  1. Crea un file YAML della policy di autorizzazione per negare determinate richieste.

    L'esempio seguente crea un file authz-policy-deny.yaml per la regola di forwarding LB_FORWARDING_RULE nella località global. Il criterio nega l'accesso al percorso URL /api/payments ai client che hanno www.example.com nei nomi DNS SAN del certificato client.

    $ 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:
      - principalSelector: CLIENT_CERT_DNS_NAME_SAN
        exact: "www.example.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 Google Cloud progetto.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Crea una policy di autorizzazione e importa il file YAML.

    Il seguente comando di esempio importa il file della policy creato in precedenza e crea una policy di autorizzazione:

    gcloud beta network-security authz-policies import my-authz-policy-deny \
    --source=authz-policy-deny.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 un criterio di autorizzazione:

  1. Crea un file YAML della policy di autorizzazione per negare determinate richieste.

    L'esempio seguente crea un file authz-policy-deny.yaml per la regola di inoltro LB_FORWARDING_RULE in una regioneGoogle Cloud . Il criterio nega l'accesso al percorso URL /api/payments ai client che hanno www.example.com nei SAN del nome DNS del certificato client.

    $ 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:
      - principalSelector: CLIENT_CERT_DNS_NAME_SAN
        exact: "www.example.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 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 Google Cloud progetto.
    • LOCATION: la tua Google Cloud regione.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Crea una policy di autorizzazione e importa il file YAML.

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

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

Policy di autorizzazione per consentire le richieste

Questa sezione fornisce un esempio di criterio di autorizzazione che consente le richieste provenienti da intervalli di indirizzi IP specifici.

Globale e interregionale

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 un criterio di autorizzazione:

  1. Crea un file YAML della policy di autorizzazione per consentire determinate richieste.

    L'esempio seguente crea un file authz-policy-allow.yaml per la regola di forwarding LB_FORWARDING_RULE nella località global. Il criterio consente ai client con indirizzi IP nell'intervallo 10.0.0.1/24 di accedere al percorso 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:
    - ipBlocks:
      - prefix: "10.0.0.1"
        length: "24"
  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 Google Cloud progetto.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Crea una policy di autorizzazione e importa il file YAML.

    Il seguente comando di esempio importa il file della policy creato in precedenza e crea una policy di autorizzazione:

    gcloud beta network-security authz-policies import my-authz-policy-allow \
    --source=authz-policy-allow.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 un criterio di autorizzazione:

  1. Crea un file YAML della policy di autorizzazione per consentire determinate richieste.

    L'esempio seguente crea un file authz-policy-allow.yaml per la regola di forwarding LB_FORWARDING_RULE in una regione Google Cloud specifica. Il criterio consente ai client con indirizzi IP nell'intervallo 10.0.0.1/24 di accedere al percorso 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/regions/LOCATION/forwardingRules/LB_FORWARDING_RULE"
httpRules:
- from:
    sources:
    - ipBlocks:
      - prefix: "10.0.0.1"
        length: "24"
  to:
    operations:
    - paths:
      - exact: "/api/payments"
action: ALLOW
EOF

    Sostituisci quanto segue:

    • LB_SCHEME: lo schema di bilanciamento del carico. Se utilizzi il 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 Google Cloud progetto.
    • LOCATION: la tua Google Cloud regione.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Crea una policy di autorizzazione e importa il file YAML.

    Il seguente comando di esempio importa il file della policy creato in precedenza e crea una policy di autorizzazione nella regione LOCATION:

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

Policy di autorizzazione basata su service account o tag

Puoi applicare le norme di autorizzazione in base ai service account o ai tag solo ai bilanciatori del carico delle applicazioni interni. Qualsiasi traffico proveniente da una VM client collegata a un account di serviziot o a un tag specifico può essere consentito, negato o delegato a un servizio esterno.

Se vuoi creare e collegare service account o tag alle VM Google Cloud , consulta la sezione Crea e collega service account o tag alle VM Google Cloud in questo documento.

Service account

  1. Crea un file YAML della policy di autorizzazione per negare determinate richieste.

    L'esempio seguente crea un file authz-policy-deny.yaml per la regola di forwarding LB_FORWARDING_RULE di un bilanciatore del carico delle applicazioni interno regionale. Il criterio è configurato per negare le richieste provenienti da qualsiasi VM client con il account di servizio my-sa-123@PROJECT_ID.iam.gserviceaccount.com per raggiungere il percorso /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:
    - 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: lo schema di bilanciamento del carico. Per un bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
    • PROJECT_ID: l'ID del tuo Google Cloud progetto.
    • LOCATION: la tua Google Cloud regione.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Crea una policy di autorizzazione e importa il file YAML.

    Il seguente comando di esempio importa il file della policy creato in precedenza e crea una policy di autorizzazione nella regione Google Cloud specificata.

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

    Sostituisci quanto segue:

    • LOCATION: la tua Google Cloud regione.

Tag

  1. Crea un file YAML della policy di autorizzazione per consentire determinate richieste.

    L'esempio seguente crea un file authz-policy-allow.yaml per la regola di forwarding LB_FORWARDING_RULE di un bilanciatore del carico delle applicazioni interno regionale. Il criterio consente solo alle richieste provenienti da una VM con il tag risorsa TAG_VALUE di accedere al 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/regions/LOCATION/forwardingRules/LB_FORWARDING_RULE"
httpRules:
- from:
  sources:
    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. Per un bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
    • PROJECT_ID: l'ID del tuo Google Cloud progetto.
    • LOCATION: la tua Google Cloud regione.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

  2. Crea una policy di autorizzazione e importa il file YAML.

    Il seguente comando di esempio importa il file della policy creato in precedenza e crea una policy di autorizzazione nella regioneGoogle Cloud specificata:

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

    Sostituisci quanto segue:

    • LOCATION: la tua Google Cloud regione.

Policy di autorizzazione per la delega 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.

Globale e interregionale

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 un criterio di autorizzazione:

  1. Crea un file di policy 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 località global. La policy chiama l'estensione AUTHZ_EXTENSION per tutto il traffico verso il percorso 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 Google Cloud progetto.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.
    • AUTHZ_EXTENSION: il nome dell'estensione dell'autorizzazione.

  2. Crea una policy di autorizzazione e importa il file YAML.

    Il seguente comando di esempio importa il file della policy creato in precedenza e crea una policy 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 un criterio di autorizzazione:

  1. Crea un file YAML dei criteri 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 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 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: lo 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 Google Cloud progetto.
    • LOCATION: la tua Google Cloud regione.
    • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.
    • AUTHZ_EXTENSION: il nome dell'estensione dell'autorizzazione.

  2. Crea una policy di autorizzazione e importa il file YAML.

    Il seguente comando di esempio importa il file della policy creato in precedenza e crea una policy di autorizzazione nella regione LOCATION:

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

Testare un criterio di autorizzazione

Per testare un criterio di autorizzazione, invia un po' di traffico al bilanciatore del carico. Per maggiori informazioni, consulta le seguenti pagine:

Informazioni sui log delle norme di autorizzazione in Cloud Logging

Per capire come vengono registrate le policy di autorizzazione quando una richiesta viene consentita o negata, consulta le sezioni seguenti.

La richiesta non corrisponde alle norme ALLOW né a quelle DENY

Quando una richiesta non corrisponde né alle norme ALLOW né a quelle DENY, le norme DENY consentono la richiesta e la registrano come allowed_as_no_deny_policies_matched_request. Al contrario, il criterio ALLOW rifiuta la richiesta e la registra come denied_as_no_allow_policies_matched_request. Poiché una delle norme nega la richiesta, quest'ultima 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"
      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 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"
  }

La richiesta è conforme alle norme DENY

Quando una richiesta corrisponde alla norma DENY, viene negata e la norma che ha negato la richiesta viene registrata.

  • Se utilizzi un bilanciatore del carico delle applicazioni esterno globale, statusDetails è impostato su denied_by_authz_policy nel log e il nome del criterio che ha negato 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 un bilanciatore del carico delle applicazioni interno tra regioni, proxyStatus è impostato su error=\"http_request_error\"; details=\"denied_by_authz_policy\" e 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"
  }

La richiesta non è conforme alle norme DENY, ma è conforme alle norme ALLOW

Quando una richiesta non corrisponde al criterio DENY, ma corrisponde al criterio ALLOW, la richiesta viene consentita. Nel log, questa 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, non è presente alcun statusDetails nel log. Anche il criterio che ha consentito la richiesta viene registrato in policies. Vedi l'esempio seguente:

      {
    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 un bilanciatore del carico delle applicazioni interno tra regioni, non è presente alcun campo proxyStatus nel log. Il criterio che ha consentito la richiesta viene 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/$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