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 account di servizio o tag alle Google Cloud VM

Per i bilanciatori del carico di applicazioni interni, puoi applicare criteri di autorizzazione in base agli account o ai tag dei servizi associati a risorse Google Clouddiverse.

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

L'applicazione di criteri di autorizzazione in base a tag o account di servizio non è supportata per i bilanciatori del carico delle applicazioni esterni.

Collega gli account di servizio alle VM client

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

Allega i 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, assegnalo a un scopoGCE_FIREWALL. Google Cloud Le funzionalità di rete, tra cui Secure Web Proxy e i criteri di autorizzazione, richiedono lo scopo GCE_FIREWALL per applicare il tag.

Creare una chiave e un valore tag

Per creare i 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. Inserisci una descrizione nel campo Descrizione chiave tag.

  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. Inserisci una descrizione nel campo Descrizione del valore del tag.

  10. Quando hai finito di aggiungere i 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 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 del tag numerico.

Collega 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 VM o ai backend del modello.

Per associare i tag, devi disporre del ruolo Taggare utenti (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. Recupera 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 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 del tag sicuro.
    • TAG_VALUE: il valore numerico del tag.

Crea il criterio di autorizzazione

Per creare un criterio di autorizzazione, crea un file YAML che definisce il target 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 associati alla regola di forwarding di un bilanciatore del carico.

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. Crea il file del criterio di autorizzazione per negare determinate richieste.

    L'esempio seguente crea un file authz-policy-deny.yaml per la regola di inoltro LB_FORWARDING_RULE nella posizione global. Il criterio impedisce ai client di *.hello.com di accedere al percorso 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/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 seguente comando di esempio importa il file di 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 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. Crea il file del criterio 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 regione Google Cloud . Il criterio nega ai client con identità corrispondenti a *.hello.com di accedere al percorso 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"
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 progetto Google Cloud.
    • LOCATION: la tua Google Cloud regione.
    • 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 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.

    L'esempio seguente crea un file authz-policy-allow.yaml per la regola di inoltro LB_FORWARDING_RULE nella posizione global. Il criterio consente solo ai client di *.example.com 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/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 seguente comando di esempio importa il file di 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 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. Crea il file del criterio 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 specifica. Il criterio consente solo ai client di *.example.com 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:
  - principals:
    - suffix: ".example.com"
  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 un 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 Google Cloud regione.
    • 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 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 basato su tag o account di servizio

Puoi applicare i criteri di autorizzazione basati su tag o account di servizio solo ai bilanciatori del carico delle applicazioni interni. Qualsiasi traffico proveniente da una VM client collegata a un account di servizio o a un tag specifico può essere consentito, negato o delegato a un servizio esterno.

Se vuoi creare e collegare account di servizio o tag alle Google Cloud VM, consulta la sezione Creare e collegare account di servizio o tag alle Google Cloud VM in questo documento.

Service account

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

    L'esempio seguente crea un file authz-policy-deny.yaml per la regola di inoltro 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 l'account di serviziomy-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 progetto Google Cloud.
    • LOCATION: la tua Google Cloud regione.
    • 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 seguente comando di esempio importa il file di criteri creato in precedenza e crea il criterio 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 il file del criterio di autorizzazione per consentire determinate richieste.

    L'esempio seguente crea un file authz-policy-allow.yaml per la regola di inoltro LB_FORWARDING_RULE di un bilanciatore del carico delle applicazioni interno a livello di regione. 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 progetto Google Cloud.
    • LOCATION: la tua Google Cloud regione.
    • 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 seguente comando di esempio importa il file di criteri creato in precedenza e crea i criteri 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.

Criterio di autorizzazione da 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 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 delegare determinate richieste a un servizio esterno.

    L'esempio seguente crea un file authz-policy-custom.yaml per la regola di inoltro 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 seguente comando di esempio importa il file di 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. 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 inoltro LB_FORWARDING_RULE in una regione Google Cloud di un bilanciatore del carico delle applicazioni interno a livello di regione. 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: 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 progetto Google Cloud.
    • 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 di autorizzazione.

  2. Crea il criterio di autorizzazione e importa 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-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 maggiori informazioni, consulta le seguenti pagine:

Informazioni sui log dei criteri di autorizzazione in Cloud Logging

Per capire in che modo vengono registrati i criteri di autorizzazione quando una richiesta viene consentita o rifiutata, consulta le sezioni seguenti.

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

Quando una richiesta non corrisponde ai criteri ALLOW o DENY, il criterio DENY consente la richiesta e la registra 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 rifiuta 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 a livello di regione, un bilanciatore del carico delle applicazioni esterno a livello di regione 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 corrisponde alle norme di DENY

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 e il nome del criterio che ha negato la richiesta è 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 corrisponde alle norme di DENY, ma corrisponde alle norme di ALLOW

Quando una richiesta non corrisponde al criterio DENY, ma corrisponde al criterio ALLOW, la richiesta è 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, nel log non è presente statusDetails. Il criterio che ha consentito la richiesta è registrato anche 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 a livello di regione, un bilanciatore del carico delle applicazioni esterno a livello di regione o un bilanciatore del carico delle applicazioni interno tra regioni, nel log non è presente il 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