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 seguenti pagine 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 creare diversi tipi di policy di autorizzazione associate alla regola di forwarding di un bilanciatore del carico.

Policy di autorizzazione per negare le richieste

Questa sezione fornisce un esempio di policy di autorizzazione che nega le richieste in base a determinati attributi della richiesta.

Nota: la policy di autorizzazione basata sulle entità non è supportata sui bilanciatori del carico delle applicazioni esterni globali.

Globale

Se utilizzi un bilanciatore del carico delle applicazioni esterno globale, segui questi passaggi per creare e importare una policy di autorizzazione che nega le richieste in base agli intervalli di indirizzi IP:

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

   L'esempio seguente crea un file authz-policy-deny.yaml per la regola di inoltro LB_FORWARDING_RULE nella località global. Il criterio 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 il bilanciatore del carico delle applicazioni esterno globale, imposta lo schema su EXTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

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

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

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

Tra regioni

Se utilizzi un bilanciatore del carico delle applicazioni interno tra regioni, segui questi passaggi per creare e importare una policy di autorizzazione che nega le richieste in base ai principal del certificato client.

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

   L'esempio seguente crea un file authz-policy-deny.yaml per la regola di forwarding LB_FORWARDING_RULE nella località global. Il criterio nega l'accesso al percorso 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 il bilanciatore del carico delle applicazioni interno tra regioni, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

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

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

   gcloud 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 una policy di autorizzazione che nega le richieste in base ai soggetti del certificato client.

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

   L'esempio seguente crea un file authz-policy-deny.yaml per la regola di inoltro LB_FORWARDING_RULE in una regioneGoogle Cloud . Il criterio nega l'accesso al percorso 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 il bilanciatore del carico delle applicazioni esterno regionale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LOCATION: la tua Google Cloud regione.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

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

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

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

Policy di autorizzazione per consentire le richieste

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

Globale e cross-regionale

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

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

   L'esempio seguente crea un file authz-policy-allow.yaml per la regola di forwarding LB_FORWARDING_RULE nella località global. 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 il bilanciatore del carico delle applicazioni esterno globale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno tra regioni, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

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

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

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

Regionale

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

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

   L'esempio seguente crea un file authz-policy-allow.yaml per la regola di inoltro 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. Se utilizzi il bilanciatore del carico delle applicazioni esterno regionale, imposta lo schema su EXTERNAL_MANAGED. Se utilizzi il bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LOCATION: la tua Google Cloud regione.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

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

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

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

Policy di autorizzazione basata su service account o tag

Puoi applicare un criterio di autorizzazione basato su service account o tag sicuri associati a varie Google Cloud risorse.

Questo esempio presuppone che tu abbia eseguito quanto segue:

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

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

Service account

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

   L'esempio seguente crea un file authz-policy-deny.yaml per la regola di forwarding LB_FORWARDING_RULE di un bilanciatore del carico delle applicazioni interno a livello di regione. Il criterio è configurato per negare le richieste da una risorsa Google Cloud , ad esempio una VM di Compute Engine, con l'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 un bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LOCATION: la tua Google Cloud regione.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

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

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

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

   Sostituisci LOCATION con la tua regione Google Cloud .

Tag

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

   L'esempio seguente crea un file authz-policy-allow.yaml per la regola di forwarding LB_FORWARDING_RULE di un bilanciatore del carico delle applicazioni interno regionale. La policy consente solo le richieste provenienti da una risorsa Google Cloud , ad esempio una VM di Compute Engine, con un valore del tag sicuroTAG_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 un bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LOCATION: la tua Google Cloud regione.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.
   • TAG_VALUE_PERMANENT_ID: l'ID permanente di un valore tag.

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

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

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

   Sostituisci quanto segue:

   • LOCATION: la tua Google Cloud regione.

Policy di autorizzazione per 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 backend o un servizio basato su FQDNGoogle Cloud
• Servizio gestito da Google
  • Model Armor
  • Identity-Aware Proxy

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

Puoi configurare un criterio di autorizzazione per delegare la decisione di autorizzazione a un servizio gestito dall'utente tramite le estensioni di servizio, in particolare un'estensione di autorizzazione.

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

• Per i bilanciatori del carico regionali, l'estensione di 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, chiamato anche servizio di backend di callout, denominato authz-service. Per scoprire di più su come crearne uno, consulta Configurare un servizio di backend di callout gestito dall'utente.

Per un servizio basato su FQDN, questo esempio di configurazione presuppone che il servizio personalizzato sia implementato 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 di 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 bilanciamento 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 cross-regionale

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 di autorizzazione in un file YAML. L'estensione di 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 di autorizzazione importando il file YAML dell'estensione di 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 il bilanciatore del carico delle applicazioni esterno globale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno tra regioni, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.

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

   La policy richiede l'estensione di 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 il bilanciatore del carico delle applicazioni esterno globale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno tra regioni, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

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 di autorizzazione in un file YAML. L'estensione di 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 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.
   • BACKEND_SERVICE_URI_OR_FQDN: il servizio può essere uno dei seguenti:
     • un URI di 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 di autorizzazione importando il file YAML dell'estensione di 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 di callout.

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

   La policy chiama l'estensione di 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 il bilanciatore del carico delle applicazioni esterno regionale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LOCATION: la Google Cloud regione.
   • 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 beta 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 ulteriori informazioni sulle estensioni di autorizzazione, consulta Configurare un'estensione di 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 modello Model Armor. In questa configurazione di esempio, la policy di autorizzazione punta a un'estensione di autorizzazione, che a sua volta punta 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 di autorizzazione in un file YAML. L'estensione di autorizzazione rimanda ai modelli 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 posizione del modello
   • PROJECT_ID: l'ID del progetto a cui appartiene il modello
   • RESPONSE_TEMPLATE_ID: ID del modello di risposta
   • REQUEST_TEMPLATE_ID: l'ID del modello di richiesta

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

   gcloud beta 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 il criterio di autorizzazione in un file YAML. La policy di autorizzazione delega l'autorizzazione all'estensione di 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 Google Cloud progetto.
   • LOCATION: la Google Cloud regione.
   • 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 beta network-security authz-policies import.

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

Delegare 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 di autorizzazione. Per questi bilanciatori del carico, puoi delegare la decisione di autorizzazione a IAP tramite il campo customProvider nella risorsa dei criteri 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 di autorizzazione.

Globale e cross-regionale

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 il criterio 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 il bilanciatore del carico delle applicazioni esterno globale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno tra regioni, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LB_FORWARDING_RULE: il nome della regola di forwarding del bilanciatore del carico.

2. Crea 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 di autorizzazione.

1. Definisci l'estensione di autorizzazione in un file YAML. L'estensione di autorizzazione punta a IAP.

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

   Puoi anche configurare IAP per l'esecuzione in modalità dry run per testare una policy di autorizzazione con il traffico di produzione live senza applicarla. In questo modo puoi verificare la tua policy e ridurre al minimo il rischio di interruzione del traffico a causa di errori di configurazione.

   cat >authz-extension.yaml <<EOF
   name: my-authz-ext
   loadBalancingScheme: LB_SCHEME
   service: iap.googleapis.com
   failOpen: false
   metadata:'
     iamEnforcementMode: DRY_RUN
   '
   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.

2. Crea l'estensione di autorizzazione importando il file YAML dell'estensione di 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 Google Cloud regione in cui è configurata l'estensione di autorizzazione.

3. Definisci il criterio di autorizzazione in un file YAML. La policy di autorizzazione delega l'autorizzazione all'estensione di 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 il bilanciatore del carico delle applicazioni esterno regionale, imposta lo schema su EXTERNAL_MANAGED. Per il bilanciatore del carico delle applicazioni interno regionale, imposta lo schema su INTERNAL_MANAGED.
   • PROJECT_ID: l'ID del tuo Google Cloud progetto.
   • LOCATION: la Google Cloud regione.
   • 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 beta 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 norme ALLOW né a quelle DENY

Quando una richiesta non corrisponde alle policy ALLOW né 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, la richiesta viene rifiutata.

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

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

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

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

La richiesta è conforme alle norme DENY

Quando una richiesta corrisponde alla 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 del criterio che ha negato la richiesta viene registrato in policies. Vedi il seguente esempio:

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

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

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

La richiesta non corrisponde alle norme DENY, ma corrisponde alle norme 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, non è presente statusDetails nel log. Anche la policy che ha consentito la richiesta viene registrata in policies. Vedi l'esempio seguente:

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

• Se utilizzi un bilanciatore del carico delle applicazioni interno regionale, un bilanciatore del carico delle applicazioni esterno regionale o un bilanciatore del carico delle applicazioni interno tra regioni, nel log non è presente il campo proxyStatus. La policy che ha consentito la richiesta viene registrata anche in policies. Vedi il seguente esempio:

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

Passaggi successivi

• Configurare un'estensione di autorizzazione

• Delega l'autorizzazione a IAP e IAM