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

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

Prima di iniziare

• Acquisisci familiarità con la panoramica delle policy di autorizzazione.

• Abilita le seguenti API:

  • API per la sicurezza di rete
  • API Network Services

Configura il bilanciatore del carico

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

• Per creare un bilanciatore del carico delle applicazioni esterno globale, consulta Configura 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 Configura 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 Configura 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 Configura un bilanciatore del carico delle applicazioni interno tra regioni con backend di gruppi di istanze VM.

Crea una policy 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 network-security authz-policies.

Questa sezione fornisce istruzioni per la creazione di policy di autorizzazione collegate alla regola di forwarding dei bilanciatori del carico delle applicazioni.

Per scoprire di più su come creare una policy di autorizzazione per un Agent Gateway che delega l'autorizzazione utilizzando Service Extensions, consulta Delega l'autorizzazione con Service Extensions.

Per scoprire di più su come creare una policy di autorizzazione per un Secure Web Proxy, consulta Configura le policy di autorizzazione per Secure Web Proxy.

Policy di autorizzazione per rifiutare le richieste

Questa sezione fornisce esempi di policy di autorizzazione che negano le richieste in base a determinati attributi della richiesta.

Nega le richieste in base agli intervalli di indirizzi IP

Questa sezione fornisce un esempio di policy di autorizzazione che nega le richieste in base alle richieste provenienti da intervalli di indirizzi IP specifici.

Globale e tra regioni

1. Definisci la policy di autorizzazione in un file YAML.

   L'esempio seguente crea un file authz-policy-deny.yaml per la regola di forwarding LB_FORWARDING_RULE nella località global. La policy nega ai client con indirizzi IP nell'intervallo 10.0.0.0/24 l'accesso 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:
       - ipBlocks:
         - prefix: "10.0.0.0"
           length: "24"
   - to:
       operations:
       - paths:
         - prefix: "/api/payments"
   action: DENY
   EOF
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni globali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni 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 la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

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

Regionale

1. Definisci la policy di autorizzazione in un file YAML.

   L'esempio seguente crea un file authz-policy-deny.yaml per la regola di forwarding LB_FORWARDING_RULE in una regioneGoogle Cloud . La policy nega ai client con indirizzi IP nell'intervallo 10.0.0.0/24 l'accesso 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/regions/LOCATION/forwardingRules/LB_FORWARDING_RULE"
   httpRules:
   - from:
       sources:
       - ipBlocks:
         - prefix: "10.0.0.0"
           length: "24"
   - to:
       operations:
       - paths:
         - prefix: "/api/payments"
   action: DENY
   EOF
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni regionali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni regionali, 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. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

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

Nega le richieste in base alle entità dei certificati client

Questa sezione fornisce un esempio di policy di autorizzazione che nega le richieste in base alle entità del certificato client.

Globale e tra regioni

1. Definisci la policy di autorizzazione in un file YAML.

   L'esempio seguente crea un file authz-policy-deny.yaml per la regola di forwarding LB_FORWARDING_RULE nella località global. La policy nega l'accesso al percorso dell'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/global/forwardingRules/LB_FORWARDING_RULE"
   httpRules:
   - from:
       sources:
       - principals:
         - principalSelector: CLIENT_CERT_DNS_NAME_SAN
           principal:
             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 i bilanciatori del carico delle applicazioni esterni globali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni 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 la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

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

Regionale

1. Definisci la policy di autorizzazione in un file YAML.

   L'esempio seguente crea un file authz-policy-deny.yaml per la regola di forwarding LB_FORWARDING_RULE in una regioneGoogle Cloud . La policy nega l'accesso al percorso dell'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"
   policyProfile: REQUEST_AUTHZ
   httpRules:
   - from:
       sources:
       - principals:
         - principalSelector: CLIENT_CERT_DNS_NAME_SAN
           principal:
             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 i bilanciatori del carico delle applicazioni esterni regionali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni regionali, 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. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

   gcloud 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 policy 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 una policy di autorizzazione:

1. Definisci la policy di autorizzazione in un file YAML.

   L'esempio seguente crea un file authz-policy-allow.yaml per la regola di forwarding LB_FORWARDING_RULE nella località global. La policy consente ai client con indirizzi IP nell'intervallo 10.0.0.0/24 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:
       - ipBlocks:
         - prefix: "10.0.0.0"
           length: "24"
     to:
       operations:
       - paths:
         - exact: "/api/payments"
   action: ALLOW
   EOF
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni globali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni 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 la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

   gcloud 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 una policy di autorizzazione:

1. Definisci la policy di autorizzazione in un file YAML.

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

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni regionali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni regionali, 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. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

   gcloud 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 una policy di autorizzazione basata su service account o tag sicuricollegati a varie risorse Google Cloud .

Questo esempio presuppone che tu abbia eseguito quanto segue:

• creato un service account e lo hai collegato a una risorsa Google Cloud .

• creato un tag sicuro e lo hai collegato a una risorsa Google Cloud come coppia chiave-valore. Quando crei un tag, imposta il relativo flag --purpose su GCE_FIREWALL. Le policy di autorizzazione richiedono lo scopo GCE_FIREWALL per applicare il tag.

Service account

1. Definisci la policy di autorizzazione in un file YAML.

   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. La policy è configurata per rifiutare le richieste provenienti da una risorsa Google Cloud , ad esempio una VM di Compute Engine, 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"
   policyProfile: REQUEST_AUTHZ
   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 i bilanciatori del carico delle applicazioni interni regionali e i bilanciatori del carico delle applicazioni interni tra regioni, 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. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

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

   Sostituisci LOCATION con la tua regione Google Cloud .

Tag

1. Definisci la policy di autorizzazione in un file YAML.

   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. La policy consente solo le richieste provenienti da una risorsa Google Cloud , ad esempio una VM di Compute Engine, con un valore del tag sicuro TAG_VALUE_PERMANENT_ID per 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"
   policyProfile: REQUEST_AUTHZ
   httpRules:
   - from:
     sources:
       resources:
       - tagValueIdSet:
         - ids: "TAG_VALUE_PERMANENT_ID"
     to:
       operations:
       - paths:
         - exact: "/api/payments"
   action: ALLOW
   EOF
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni interni regionali e i bilanciatori del carico delle applicazioni interni tra regioni, 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.
   • TAG_VALUE_PERMANENT_ID: l'ID permanente di un valore tag.

2. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

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

   Sostituisci quanto segue:

   • LOCATION: la tua regione Google Cloud .

Policy di autorizzazione per delegare le decisioni di autorizzazione

Gli esempi in questa sezione creano una policy di autorizzazione che delega le decisioni di autorizzazione ai seguenti servizi tramite Service Extensions:

• Servizio gestito dall'utente
  • un servizio di backendGoogle Cloud o un servizio basato su FQDN
• Servizio gestito da Google
  • Model Armor
  • Identity-Aware Proxy

Delega la decisione di autorizzazione a un servizio gestito dall'utente

Puoi configurare una policy di autorizzazione per delegare la decisione di autorizzazione a un servizio gestito dall'utente tramite le estensioni dei servizi, in particolare un'estensione dell'autorizzazione.

• Per i bilanciatori del carico globali e tra regioni, l'estensione dell'autorizzazione può essere eseguita su un servizio di backend Google Cloud gestito dall'utente.

• Per i bilanciatori del carico regionali, l'estensione dell'autorizzazione può essere eseguita sia su un servizio di backend Google Cloud gestito dall'utente sia su un servizio basato su FQDN.

Questa configurazione di esempio presuppone che tu abbia creato un servizio di backend Google Cloud gestito dall'utente, denominato anche servizio di backend di callout, denominato authz-service. Per scoprire di più su come crearne uno, consulta Configura un servizio di backend di callout gestito dall'utente.

Per un servizio basato su FQDN, questa configurazione di esempio presuppone che il servizio personalizzato sia distribuito nel tuo VPC, supporti il protocollo ext_authz e sia accessibile tramite il nome di dominio completo mycustomauthz.internal.net.

Nota: quando indirizzi un'estensione dell'autorizzazione a un dominio (FQDN), il bilanciatore del carico utilizza il protocollo HTTP/2 con crittografia TLS per comunicare con gli endpoint sulla porta 443. Tuttavia, anche se il traffico è criptato, il bilanciatore del carico non convalida il certificato del server, il che significa che accetta qualsiasi certificato fornito dal server, anche se scaduto, autofirmato o destinato a un dominio diverso. Per assicurarti che il bilanciatore del carico comunichi solo con servizi attendibili, assicurati che l'FQDN venga risolto in un indirizzo IP all'interno del tuo ambiente VPC.

Globale e tra regioni

Se utilizzi un bilanciatore del carico delle applicazioni esterno globale o un bilanciatore del carico delle applicazioni interno tra regioni, segui questi passaggi per delegare la decisione di autorizzazione al servizio gestito dall'utente.

1. Definisci l'estensione dell'autorizzazione in un file YAML. L'estensione dell'autorizzazione viene eseguita su un servizio di backend (authz-service) e supporta il protocollo ext_authz.

   cat >authz-extension.yaml <<EOF
   name: my-authz-ext
   authority: ext11.com
   loadBalancingScheme: LB_SCHEME
   service: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/authz-service
   forwardHeaders:
     - Authorization
   failOpen: false
   timeout: "0.1s"
   wireFormat: EXT_AUTHZ_GRPC
   EOF
   

2. Crea l'estensione dell'autorizzazione importando il file YAML dell'estensione dell'autorizzazione utilizzando il comando gcloud service-extensions authz-extensions import.

   gcloud service-extensions authz-extensions import my-authz-ext \
       --source=authz-extension.yaml \
       --location=global
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni globali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni tra regioni, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo progetto Google Cloud .

3. Definisci la policy di autorizzazione in un file YAML. La policy di autorizzazione delega l'autorizzazione all'estensione dell'autorizzazione nel campo customProvider.

   La policy chiama l'estensione dell'autorizzazione my-authz-ext per tutto il traffico verso il percorso dell'URL example.com/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:
       - hosts:
         - exact: "example.com"
       - paths:
         - exact: "/api/payments"
     when: 'request.headers["Authorization"] != ""'
   action: CUSTOM
   customProvider:
     authzExtension:
       resources:
       - "projects/PROJECT_ID/locations/global/authzExtensions/my-authz-ext"
   EOF
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni globali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni 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.

4. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

   gcloud 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 delegare la decisione di autorizzazione a un servizio gestito dall'utente.

1. Definisci l'estensione dell'autorizzazione in un file YAML. L'estensione dell'autorizzazione può essere eseguita su un servizio di backend o su un servizio basato su FQDN.

   cat >authz-extension.yaml <<EOF
   name: my-authz-ext
   authority: ext11.com
   loadBalancingScheme: LB_SCHEME
   service: BACKEND_SERVICE_URI_OR_FQDN
   forwardHeaders:
     - Authorization
   failOpen: false
   timeout: "0.1s"
   wireFormat: EXT_AUTHZ_GRPC
   EOF
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni regionali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni regionali, imposta lo schema su INTERNAL_MANAGED.
   • BACKEND_SERVICE_URI_OR_FQDN: il servizio può essere uno dei seguenti:
     • un URI della risorsa del servizio di backend regionale nel formato https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/LOCATION/backendServices/authz-service.
     • un nome di dominio completo (ad esempio mycustomauthz.extension.net) che può essere risolto da Cloud DNS.

2. Crea l'estensione dell'autorizzazione importando il file YAML dell'estensione dell'autorizzazione utilizzando il comando gcloud service-extensions authz-extensions import.

   gcloud service-extensions authz-extensions import my-authz-ext \
       --source=authz-extension.yaml \
       --location=LOCATION
   

   Sostituisci LOCATION con la regione Google Cloud in cui è configurato il servizio di backend del callout.

3. Definisci la policy di autorizzazione in un file YAML. La policy di autorizzazione delega l'autorizzazione all'estensione dell'autorizzazione nel campo customProvider.

   La policy chiama l'estensione dell'autorizzazione my-authz-ext per tutto il traffico verso il percorso dell'URL example.com/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"
   policyProfile: REQUEST_AUTHZ
   httpRules:
   - to:
       operations:
       - paths:
         - exact: "/api/payments"
     when: 'request.headers["Authorization"] != ""'
   action: CUSTOM
   customProvider:
     authzExtension:
       resources:
       - "projects/PROJECT_ID/locations/LOCATION/authzExtensions/my-authz-ext"
   EOF
   

   Sostituisci quanto segue:

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

4. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

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

   Sostituisci LOCATION con la regione Google Cloud in cui è configurato il bilanciatore del carico.

Per saperne di più sulle estensioni dell'autorizzazione, consulta Configura un'estensione dell'autorizzazione.

Delega la decisione di autorizzazione a Model Armor

Puoi configurare una policy di autorizzazione per delegare la decisione di autorizzazione a Model Armor.

Prima di iniziare, crea un template Model Armor. In questa configurazione di esempio, la policy di autorizzazione rimanda a un'estensione dell'autorizzazione, che a sua volta rimanda a Model Armor.

Se utilizzi un bilanciatore del carico delle applicazioni esterno regionale o un bilanciatore del carico delle applicazioni interno regionale, segui questi passaggi per delegare la decisione di autorizzazione a Model Armor.

Regionale

1. Definisci l'estensione dell'autorizzazione in un file YAML. L'estensione dell'autorizzazione rimanda ai template di richiesta e risposta di Model Armor.

   cat >authz-extension.yaml <<EOF
   name: my-authz-extension
   loadBalancingScheme: INTERNAL_MANAGED
   service: modelarmor.LOCATION.rep.googleapis.com
   metadata:
     model_armor_settings: '[
       {
       "response_template_id": "projects/PROJECT_ID/locations/LOCATION/templates/RESPONSE_TEMPLATE_ID",
       "request_template_id": "projects/PROJECT_ID/locations/LOCATION/templates/REQUEST_TEMPLATE_ID"
       }
     ]'
   failOpen: true
   EOF
   

   Sostituisci quanto segue:

   • LOCATION: la località del template
   • PROJECT_ID: l'ID del progetto a cui appartiene il template
   • RESPONSE_TEMPLATE_ID: l'ID del template di risposta
   • REQUEST_TEMPLATE_ID: l'ID del template di richiesta

2. Crea l'estensione dell'autorizzazione importando il file YAML dell'estensione dell'autorizzazione utilizzando il comando gcloud service-extensions authz-extensions import.

   gcloud service-extensions authz-extensions import my-authz-ext \
     --source=authz-extension.yaml \
     --location=LOCATION
   

   Sostituisci LOCATION con la regione Google Cloud in cui si trova il bilanciatore del carico.

3. Definisci la policy di autorizzazione in un file YAML. La policy di autorizzazione delega l'autorizzazione all'estensione dell'autorizzazione nel campo customProvider.

   Il valore di policyProfile è CONTENT_AUTHZ.

   cat >authz-policy-custom.yaml <<EOF
   name: my-authz-policy-custom
   target:
     loadBalancingScheme: INTERNAL_MANAGED
     resources:
     - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/LOCATION/forwardingRules/LB_FORWARDING_RULE"
   policyProfile: CONTENT_AUTHZ
   action: CUSTOM
   customProvider:
     authzExtension:
       resources:
       - "projects/PROJECT_ID/locations/LOCATION/authzExtensions/my-authz-ext"
   EOF
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Google Cloud .
   • LOCATION: la regione Google Cloud .
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

4. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

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

   Sostituisci LOCATION con la regione Google Cloud in cui è configurato il bilanciatore del carico.

Delega la decisione di autorizzazione a Identity-Aware Proxy

Per i bilanciatori del carico delle applicazioni esterni globali e i bilanciatori del carico delle applicazioni interni tra regioni, non puoi delegare la decisione di autorizzazione a IAP tramite un'estensione dell'autorizzazione. Per questi bilanciatori del carico, puoi delegare la decisione di autorizzazione a IAP tramite il campo customProvider nella risorsa della policy di autorizzazione.

Per i bilanciatori del carico delle applicazioni esterni regionali e i bilanciatori del carico delle applicazioni interni regionali, puoi configurare una policy di autorizzazione per delegare la decisione di autorizzazione a IAP tramite un'estensione dell'autorizzazione.

Globale e tra regioni

Nell'esempio seguente, tutte le decisioni di autorizzazione vengono delegate a IAP per tutte le richieste provenienti dal blocco di indirizzi IP 10.0.0.0/24. Se le richieste provengono da un indirizzo IP esterno a 10.0.0.0/24, non corrispondono a questa policy e non vengono valutate da IAP in base a questa regola specifica.

1. Definisci la policy di autorizzazione in un file YAML. La policy di autorizzazione delega l'autorizzazione a IAP tramite il campo customProvider.

   cat >authz-policy-iap.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:
     - from:
         sources:
         - ipBlock:
           - prefix: "10.0.0.0"
             length: 24
   action: CUSTOM
   customProvider:
     cloudIap: {}
   EOF
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni globali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni 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 la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

   gcloud network-security authz-policies import my-authz-policy-custom \
       --source=authz-policy-iap.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 delegare la decisione di autorizzazione a IAP utilizzando un'estensione dell'autorizzazione.

1. Definisci l'estensione dell'autorizzazione in un file YAML. L'estensione dell'autorizzazione rimanda a IAP.

   cat >authz-extension.yaml <<EOF
   name: my-authz-ext
   loadBalancingScheme: LB_SCHEME
   service: iap.googleapis.com
   failOpen: false
   EOF
   

   Sostituisci quanto segue:

   • LB_SCHEME: lo schema di bilanciamento del carico. Per i bilanciatori del carico delle applicazioni esterni regionali, imposta lo schema su EXTERNAL_MANAGED. Per i bilanciatori del carico delle applicazioni interni regionali, imposta lo schema su INTERNAL_MANAGED.

2. Crea l'estensione dell'autorizzazione importando il file YAML dell'estensione dell'autorizzazione utilizzando il comando gcloud service-extensions authz-extensions import.

   gcloud service-extensions authz-extensions import my-authz-ext \
       --source=authz-extension.yaml \
       --location=LOCATION
   

   Sostituisci LOCATION con la regione Google Cloud in cui è configurata l'estensione dell'autorizzazione.

3. Definisci la policy di autorizzazione in un file YAML. La policy di autorizzazione delega l'autorizzazione all'estensione dell'autorizzazione nel campo customProvider.

   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"
   policyProfile: REQUEST_AUTHZ
   action: CUSTOM
   customProvider:
     authzExtension:
       resources:
       - "projects/PROJECT_ID/locations/LOCATION/authzExtensions/my-authz-ext"
   EOF
   

   Sostituisci quanto segue:

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

4. Crea la policy di autorizzazione importando il file YAML della policy di autorizzazione utilizzando il comando gcloud network-security authz-policies import.

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

   Sostituisci LOCATION con la regione Google Cloud in cui è configurato il bilanciatore del carico.

Informazioni sui log delle policy 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 policy ALLOW né DENY

Quando una richiesta non corrisponde né alle policy ALLOW né alle policy DENY, la policy DENY consente la richiesta e la registra come allowed_as_no_deny_policies_matched_request. Al contrario, la policy ALLOW rifiuta la richiesta e la registra come denied_as_no_allow_policies_matched_request. Poiché una delle policy 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 l'esempio che segue:

    {
      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 l'esempio che segue:

    {
      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 alla policy DENY

Quando una richiesta corrisponde alla policy DENY, viene rifiutata e la policy che ha rifiutato 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 della policy che ha rifiutato la richiesta viene registrato in policies. Vedi l'esempio che segue:

    {
      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 della policy viene registrato in policies. Vedi l'esempio che segue:

    {
      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 alla policy DENY, ma corrisponde alla policy ALLOW

Quando una richiesta non corrisponde alla policy DENY, ma corrisponde alla policy ALLOW, la richiesta viene consentita. Nel log, questa azione viene registrata come allowed_as_no_deny_policies_matched_request per la policy DENY. Viene registrata anche la policy che ha consentito la richiesta.

• Se utilizzi un bilanciatore del carico delle applicazioni esterno globale, nel log non è presente statusDetails. Anche la policy che ha consentito la richiesta viene registrata 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/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, nel log non è presente alcun campo proxyStatus. Anche la policy che ha consentito la richiesta viene registrata 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

• Configura un'estensione dell'autorizzazione

• Delega l'autorizzazione a IAP e IAM