Questa pagina è stata tradotta dall'API Cloud Translation.

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

Negli Application Load Balancer, i criteri di autorizzazione vengono chiamati dopo aver valutato le estensioni di route, i criteri di sicurezza di rete (valutati da Google Cloud Armor), i criteri di condivisione delle risorse tra origini (CORS) e Identity-Aware Proxy (IAP), ma prima di eseguire le azioni di gestione del traffico.

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

Prima di iniziare

Consulta la panoramica delle norme sull'autorizzazione.
Abilita le seguenti API:
- API Network Security
- API Network Services

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:

Per creare un bilanciatore del carico delle applicazioni esterno globale, consulta Configurare un bilanciatore del carico delle applicazioni esterno globale con backend di gruppi di istanze VM.

Per creare un bilanciatore del carico delle applicazioni esterno regionale, consulta Configurare un bilanciatore del carico delle applicazioni esterno regionale con backend di gruppi di istanze VM.
Per creare un bilanciatore del carico delle applicazioni interno regionale, consulta Configurare un bilanciatore del carico delle applicazioni interno regionale con backend di gruppi di istanze VM.

Per creare un bilanciatore del carico delle applicazioni interno tra regioni, consulta Configurare un bilanciatore del carico delle applicazioni interno tra regioni con backend di gruppi di istanze VM.

Crea e configura tag o account di servizio sicuri

Con i bilanciatori del carico delle applicazioni interni, puoi applicare facoltativamente i criteri di autorizzazione in base ai tag sicuri e ai service account associati alle VM client. Se prevedi di applicare criteri di autorizzazione basati su tag, utilizza 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:

Per configurare un account di servizio durante la creazione della VM, consulta Creare una VM che utilizza un account di servizio gestito dall'utente.
Per configurare un account di servizio su una VM esistente, consulta Modificare l'account di servizio associato.

Crea le chiavi e i valori dei tag protetti

Prima di associare un tag sicuro al modello di gruppo di istanze, devi creare le chiavi e i valori dei tag. Quando crei un tag, assegnagli uno scopoGCE_FIREWALL. Le funzionalità di networking di Google Cloud, tra cui Secure Web Proxy e i criteri di autorizzazione, richiedono lo scopo GCE_FIREWALL per applicare il tag.

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

Console

Nella console Google Cloud, vai alla pagina Tag.

Vai a Tag
Fai clic su Crea.
Inserisci una descrizione nel campo Descrizione chiave tag.
Seleziona la casella di controllo Per l'utilizzo con un firewall di rete.
Nell'elenco Progetto, seleziona il progetto Google Cloud in cui vuoi creare il tag.
Nel campo Rete, seleziona LB_NETWORK.
Fai clic su Aggiungi valore.
Nel campo Valore tag, inserisci TAG_VALUE. Il valore deve essere numerico.
Inserisci una descrizione nel campo Descrizione del valore del tag.
Quando hai finito di aggiungere i valori dei tag, fai clic su Crea chiave tag.

gcloud

Crea la chiave tag sicura.
```
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.
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 i tag protetti, devi disporre del ruolo Tag User (roles/resourcemanager.tagUser).

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.
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 regione Google Cloud.

Concatena i valori di FULL_NAME_PREFIX e TEMPLATE_ID:

PARENT="$FULL_NAME_PREFIX$TEMPLATE_ID"
echo $PARENT

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, 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:

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 dell'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.
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:

Crea il file del criterio 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 inoltre 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: 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 regione Google Cloud.
- LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.
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

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.
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

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 di un bilanciatore del carico delle applicazioni interno a livello di regione. Il criterio consente solo ai client di *.example.com di accedere al percorso dell'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 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 regione Google Cloud.
- LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.
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 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

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.
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

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 regione Google Cloud.
- LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.
- AUTHZ_EXTENSION: il nome dell'estensione di autorizzazione.
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:

Se utilizzi un bilanciatore del carico delle applicazioni esterno globale, consulta Testare il traffico inviato alle tue istanze.

Se utilizzi un bilanciatore del carico delle applicazioni esterno regionale, consulta Testare il bilanciatore del carico.
Se utilizzi un bilanciatore del carico delle applicazioni interno regionale, consulta Testa il bilanciatore del carico.

Se utilizzi un bilanciatore del carico delle applicazioni interno tra regioni, consulta Testa il bilanciatore del carico.

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 quanto segue:

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 neghi 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"
      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 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"
  }

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"
  }

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 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 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"
  }

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

Prima di iniziare

Configura il bilanciatore del carico

Crea e configura tag o account di servizio sicuri

Collega gli account di servizio alle VM client

Crea le chiavi e i valori dei tag protetti

Console

gcloud

Collega il tag sicuro al modello di gruppo di istanze

Crea il criterio di autorizzazione

Criterio di autorizzazione per rifiutare le richieste

Globali e interregionali

Regionale

Criterio di autorizzazione per consentire le richieste

Globali e interregionali

Regionale

Criterio di autorizzazione da delegare a un'estensione di servizio

Globali e interregionali

Regionale

Testa i criteri di autorizzazione

Informazioni sui log dei criteri di autorizzazione in Cloud Logging

Passaggi successivi