Configurer des règles d'autorisation pour les équilibreurs de charge d'application

Cette page vous explique comment configurer des règles d'autorisation pour les équilibreurs de charge d'application.

Avant de commencer

Configurer l'équilibreur de charge

Si vous n'avez pas créé d'équilibreur de charge, consultez les pages suivantes pour configurer l'équilibreur de charge d'application de votre choix :

Créer une règle d'autorisation

Pour créer une règle d'autorisation, vous devez créer un fichier YAML définissant la cible et les règles, puis l'importer à l'aide de la commande gcloud network-security authz-policies.

Cette section explique comment créer des règles d'autorisation associées à la règle de transfert des équilibreurs de charge d'application.

Pour savoir comment créer une règle d'autorisation pour une Agent Gateway qui délègue l'autorisation à l'aide de Service Extensions, consultez Déléguer l'autorisation avec Service Extensions.

Pour en savoir plus sur la création d'une stratégie d'autorisation pour un Secure Web Proxy, consultez Configurer des stratégies d'autorisation pour un Secure Web Proxy.

Règle d'autorisation pour refuser les requêtes

Cette section fournit des exemples de règles d'autorisation qui refusent les requêtes en fonction de certains attributs de requête.

Refuser les requêtes en fonction de plages d'adresses IP

Cette section fournit un exemple de stratégie d'autorisation qui refuse les requêtes provenant de plages d'adresses IP spécifiques.

Mondial et interrégional

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    L'exemple suivant crée un fichier authz-policy-deny.yaml pour la règle de transfert LB_FORWARDING_RULE dans l'emplacement global. La règle refuse aux clients dont l'adresse IP se trouve dans la plage 10.0.0.0/24 d'accéder au chemin d'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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes globaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

Régional

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    L'exemple suivant crée un fichier authz-policy-deny.yaml pour la règle de transfert LB_FORWARDING_RULE dans une régionGoogle Cloud . La règle refuse l'accès au chemin d'URL /api/payments aux clients dont l'adresse IP se trouve dans la plage 10.0.0.0/24.

    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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes régionaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes régionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : votre région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

Refuser les requêtes en fonction des comptes principaux du certificat client

Cette section fournit un exemple de stratégie d'autorisation qui refuse les requêtes en fonction des comptes principaux de certificat client.

Mondial et interrégional

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    L'exemple suivant crée un fichier authz-policy-deny.yaml pour la règle de transfert LB_FORWARDING_RULE dans l'emplacement global. La règle refuse l'accès au chemin d'URL /api/payments aux clients dont le SAN du nom DNS du certificat client contient www.example.com.

    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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes globaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

Régional

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    L'exemple suivant crée un fichier authz-policy-deny.yaml pour la règle de transfert LB_FORWARDING_RULE dans une régionGoogle Cloud . La règle refuse l'accès au chemin d'URL /api/payments aux clients dont le SAN du nom DNS du certificat client contient www.example.com.

    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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes régionaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes régionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : votre région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

Règle d'autorisation pour autoriser les requêtes

Cette section fournit un exemple de stratégie d'autorisation qui autorise les requêtes provenant de plages d'adresses IP spécifiques.

Mondial et interrégional

Si vous utilisez un équilibreur de charge d'application externe global ou un équilibreur de charge d'application interne interrégional, procédez comme suit pour créer une règle d'autorisation :

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    L'exemple suivant crée un fichier authz-policy-allow.yaml pour la règle de transfert LB_FORWARDING_RULE dans l'emplacement global. La stratégie autorise les clients dont l'adresse IP se trouve dans la plage 10.0.0.0/24 à accéder au chemin d'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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes globaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

Régional

Si vous utilisez un équilibreur de charge d'application externe régional ou un équilibreur de charge d'application interne régional, procédez comme suit pour créer et importer une règle d'autorisation :

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    L'exemple suivant crée un fichier authz-policy-allow.yaml pour la règle de transfert LB_FORWARDING_RULE dans une région Google Cloud spécifique. La stratégie autorise les clients dont l'adresse IP se trouve dans la plage 10.0.0.0/24 à accéder au chemin d'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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes régionaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes régionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : votre région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

Règle d'autorisation basée sur des comptes de service ou des tags

Vous pouvez appliquer une stratégie d'autorisation basée sur des comptes de service ou des tags sécurisés associés à différentes ressources Google Cloud .

Cet exemple suppose que vous avez effectué les opérations suivantes :

Compte de service

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    L'exemple suivant crée un fichier authz-policy-deny.yaml pour la règle de transfert LB_FORWARDING_RULE d'un équilibreur de charge d'application interne régional. La règle est configurée pour refuser les requêtes provenant d'une ressource Google Cloud , telle qu'une VM Compute Engine, avec le compte de service my-sa-123@PROJECT_ID.iam.gserviceaccount.com pour atteindre le chemin d'accès /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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application internes régionaux et interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : votre région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

    Remplacez LOCATION par votre région Google Cloud .

Tag

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    L'exemple suivant crée un fichier authz-policy-allow.yaml pour la règle de transfert LB_FORWARDING_RULE d'un équilibreur de charge d'application interne régional. La règle n'autorise que les requêtes provenant d'une ressource Google Cloud , telle qu'une VM Compute Engine, avec une valeur de tag sécuriséTAG_VALUE_PERMANENT_ID pour accéder au chemin d'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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application internes régionaux et interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : votre région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
    • TAG_VALUE_PERMANENT_ID : ID permanent d'une valeur de tag.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

    Remplacez les éléments suivants :

    • LOCATION : votre région Google Cloud .

Règle d'autorisation pour déléguer les décisions d'autorisation

Les exemples de cette section créent une règle d'autorisation qui délègue les décisions d'autorisation aux services suivants via les extensions de service :

Déléguer la décision d'autorisation à un service géré par l'utilisateur

Vous pouvez configurer une règle d'autorisation pour déléguer la décision d'autorisation à un service géré par l'utilisateur via des extensions de service, en particulier une extension d'autorisation.

  • Pour les équilibreurs de charge globaux et interrégionaux, l'extension d'autorisation peut s'exécuter sur un service de backend Google Cloud géré par l'utilisateur.

  • Pour les équilibreurs de charge régionaux, l'extension d'autorisation peut s'exécuter à la fois sur un service de backend Google Cloud géré par l'utilisateur et sur un service basé sur un FQDN.

Cet exemple de configuration suppose que vous avez créé un service de backend Google Cloud géré par l'utilisateur, également appelé service de backend de callout, nommé authz-service. Pour savoir comment en créer un, consultez Configurer un service de backend de légende géré par l'utilisateur.

Pour un service basé sur un nom de domaine complet, cet exemple de configuration suppose que le service personnalisé est déployé dans votre propre VPC, qu'il est compatible avec le protocole ext_authz et qu'il est accessible par le nom de domaine complet mycustomauthz.internal.net.

Mondial et interrégional

Si vous utilisez un équilibreur de charge d'application externe global ou un équilibreur de charge d'application interne interrégional, suivez ces étapes pour déléguer la décision d'autorisation à un service géré par l'utilisateur.

  1. Définissez l'extension d'autorisation dans un fichier YAML. L'extension d'autorisation s'exécute sur un service de backend (authz-service) et est compatible avec le protocole 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. Créez l'extension d'autorisation en important le fichier YAML de l'extension d'autorisation à l'aide de la commande gcloud service-extensions authz-extensions import.

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

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes globaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
  3. Définissez la stratégie d'autorisation dans un fichier YAML. La règle d'autorisation délègue l'autorisation à l'extension d'autorisation dans le champ customProvider.

    La règle appelle l'extension d'autorisation my-authz-ext pour tout le trafic vers le chemin d'URL example.com/api/payments lorsque la requête contient un en-tête Authorization non vide.

    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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes globaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  4. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

Régional

Si vous utilisez un équilibreur de charge d'application externe régional ou un équilibreur de charge d'application interne régional, suivez ces étapes pour déléguer la décision d'autorisation à un service géré par l'utilisateur.

  1. Définissez l'extension d'autorisation dans un fichier YAML. L'extension d'autorisation peut s'exécuter sur un service de backend ou un service basé sur un 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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes régionaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes régionaux, définissez le schéma sur INTERNAL_MANAGED.
    • BACKEND_SERVICE_URI_OR_FQDN : le service peut être l'un des suivants :
      • URI de ressource de service de backend régional au format https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/LOCATION/backendServices/authz-service.
      • un nom de domaine complet (par exemple, mycustomauthz.extension.net) pouvant être résolu par Cloud DNS.
  2. Créez l'extension d'autorisation en important le fichier YAML de l'extension d'autorisation à l'aide de la commande gcloud service-extensions authz-extensions import.

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

    Remplacez LOCATION par la région Google Cloudoù le service de backend de l'appel externe est configuré.

  3. Définissez la stratégie d'autorisation dans un fichier YAML. La stratégie d'autorisation délègue l'autorisation à l'extension d'autorisation dans le champ customProvider.

    La règle appelle l'extension d'autorisation my-authz-ext pour tout le trafic vers le chemin d'URL example.com/api/payments lorsque la requête contient un en-tête Authorization non vide.

    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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes régionaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes régionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  4. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

    Remplacez LOCATION par la région Google Cloudoù l'équilibreur de charge est configuré.

Pour en savoir plus sur les extensions d'autorisation, consultez Configurer une extension d'autorisation.

Déléguer la décision d'autorisation à Model Armor

Vous pouvez configurer une règle d'autorisation pour déléguer la décision d'autorisation à Model Armor.

Avant de commencer, créez un modèle Model Armor. Dans cet exemple de configuration, la règle d'autorisation pointe vers une extension d'autorisation, qui pointe à son tour vers Model Armor.

Si vous utilisez un équilibreur de charge d'application externe régional ou un équilibreur de charge d'application interne régional, suivez ces étapes pour déléguer la décision d'autorisation à Model Armor.

Régional

  1. Définissez l'extension d'autorisation dans un fichier YAML. L'extension d'autorisation pointe vers les modèles de requête et de réponse 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
    

    Remplacez les éléments suivants :

    • LOCATION : emplacement du modèle
    • PROJECT_ID : ID du projet auquel appartient le modèle.
    • RESPONSE_TEMPLATE_ID : ID du modèle de réponse
    • REQUEST_TEMPLATE_ID : ID du modèle de requête
  2. Créez l'extension d'autorisation en important le fichier YAML de l'extension d'autorisation à l'aide de la commande gcloud service-extensions authz-extensions import.

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

    Remplacez LOCATION par la région Google Cloudoù se trouve l'équilibreur de charge.

  3. Définissez la stratégie d'autorisation dans un fichier YAML. La stratégie d'autorisation délègue l'autorisation à l'extension d'autorisation dans le champ customProvider.

    La valeur de policyProfile est 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
    

    Remplacez les éléments suivants :

    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  4. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

    Remplacez LOCATION par la région Google Cloudoù l'équilibreur de charge est configuré.

Déléguer la décision d'autorisation à Identity-Aware Proxy

Pour les équilibreurs de charge d'application externes globaux et les équilibreurs de charge d'application internes interrégionaux, vous ne pouvez pas déléguer la décision d'autorisation à IAP via une extension d'autorisation. Pour ces équilibreurs de charge, vous pouvez déléguer la décision d'autorisation à IAP via le champ customProvider de la ressource de stratégie d'autorisation.

Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, vous pouvez configurer une stratégie d'autorisation pour déléguer la décision d'autorisation à IAP via une extension d'autorisation.

Mondial et interrégional

Dans l'exemple suivant, toutes les décisions d'autorisation sont déléguées à IAP pour toutes les requêtes provenant du bloc d'adresses IP 10.0.0.0/24. Si les requêtes proviennent d'une adresse IP en dehors de 10.0.0.0/24, elles ne correspondent pas à cette stratégie et ne sont pas évaluées par IAP en vertu de cette règle spécifique.

  1. Définissez la stratégie d'autorisation dans un fichier YAML. La règle d'autorisation délègue l'autorisation à IAP via le champ 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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes globaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

Régional

Si vous utilisez un équilibreur de charge d'application externe régional ou un équilibreur de charge d'application interne régional, suivez ces étapes pour déléguer la décision d'autorisation à IAP à l'aide d'une extension d'autorisation.

  1. Définissez l'extension d'autorisation dans un fichier YAML. L'extension d'autorisation pointe vers IAP.

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

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes régionaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes régionaux, définissez le schéma sur INTERNAL_MANAGED.
  2. Créez l'extension d'autorisation en important le fichier YAML de l'extension d'autorisation à l'aide de la commande gcloud service-extensions authz-extensions import.

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

    Remplacez LOCATION par la région Google Cloudoù l'extension d'autorisation est configurée.

  3. Définissez la stratégie d'autorisation dans un fichier YAML. La règle d'autorisation délègue l'autorisation à l'extension d'autorisation dans le champ 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
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes régionaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes régionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  4. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

    Remplacez LOCATION par la région Google Cloudoù l'équilibreur de charge est configuré.

Règle d'autorisation pour refuser les requêtes par défaut

Une règle d'autorisation avec une action DENY_BY_DEFAULT applique une référence sécurisée sur la ressource cible en bloquant toutes les requêtes, sauf si elles sont explicitement autorisées par une règle ALLOW ou CUSTOM. Cela garantit que votre ressource reste protégée même si aucune règle ALLOW n'est configurée, par exemple lorsque vous ne vous appuyez que sur des règles CUSTOM (comme IAP ou les extensions de service) ou lors de la maintenance des règles, lorsque les règles ALLOW peuvent être temporairement supprimées ou mises à jour.

Les étapes suivantes montrent comment créer une règle d'autorisation DENY_BY_DEFAULT.

Interrégional

  1. Définissez la règle d'autorisation DENY_BY_DEFAULT dans un fichier YAML.

    La stratégie cible la règle de transfert de l'équilibreur de charge et bloque toutes les requêtes qui ne sont pas explicitement autorisées par une stratégie ALLOW ou CUSTOM.

    cat >authz-policy-deny-by-default.yaml <<EOF
    name: my-authz-policy-deny-by-default
    target:
      loadBalancingScheme: LB_SCHEME
      resources:
      - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules/LB_FORWARDING_RULE"
    action: DENY_BY_DEFAULT
    EOF
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application internes interrégionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

    Cette règle établit une référence de sécurité de refus par défaut pour votre équilibreur de charge. Pour autoriser ou refuser le trafic de manière sélective, créez des règles ALLOW, DENY ou CUSTOM distinctes.

Régional

  1. Définissez la stratégie d'autorisation dans un fichier YAML.

    La stratégie cible la règle de transfert de l'équilibreur de charge et bloque toutes les requêtes qui ne sont pas explicitement autorisées par une stratégie ALLOW ou CUSTOM.

    cat >authz-policy-deny-by-default.yaml <<EOF
    name: my-authz-policy-deny-by-default
    target:
      loadBalancingScheme: LB_SCHEME
      resources:
      - "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/LOCATION/forwardingRules/LB_FORWARDING_RULE"
    action: DENY_BY_DEFAULT
    EOF
    

    Remplacez les éléments suivants :

    • LB_SCHEME : schéma d'équilibrage de charge. Pour les équilibreurs de charge d'application externes régionaux, définissez le schéma sur EXTERNAL_MANAGED. Pour les équilibreurs de charge d'application internes régionaux, définissez le schéma sur INTERNAL_MANAGED.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : région Google Cloud .
    • LB_FORWARDING_RULE : nom de la règle de transfert de l'équilibreur de charge.
  2. Créez la règle d'autorisation en important le fichier YAML de la règle d'autorisation à l'aide de la commande gcloud network-security authz-policies import.

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

    Cette règle établit une référence de sécurité de refus par défaut pour votre équilibreur de charge. Pour autoriser ou refuser le trafic de manière sélective, créez des règles ALLOW, DENY ou CUSTOM distinctes.

Journaux des règles d'autorisation dans Cloud Logging

Lorsqu'une stratégie d'autorisation est associée à la règle de transfert d'un équilibreur de charge, celui-ci enregistre les décisions d'autorisation dans Cloud Logging sous le champ jsonPayload.authzPolicyInfo.

Entrées de journal

Les exemples de cette section montrent des entrées de journal abrégées pour les requêtes HTTP évaluées par une règle d'autorisation :

La requête ne correspond ni à la règle ALLOW, ni à la règle DENY

Lorsqu'une requête ne correspond pas à la règle DENY, l'étape de la règle DENY autorise la requête et l'enregistre en tant que allowed_as_no_deny_policies_matched_request. L'évaluation passe ensuite à l'étape de la règle ALLOW. Comme la requête ne correspond pas à la règle ALLOW configurée, elle est refusée et enregistrée en tant que denied_as_no_allow_policies_matched_request.

Étant donné que l'étape ALLOW a refusé la requête, le résultat global (jsonPayload.authzPolicyInfo.result) est consigné en tant que DENIED.

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

La requête correspond à la règle DENY

Lorsqu'une requête correspond à la règle DENY, elle est immédiatement refusée et le nom de la règle qui l'a refusée est consigné.

{
  jsonPayload: {
    @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
    authzPolicyInfo: {
      policies: [
        0: {
          name: "projects/12345567/locations/global/authzPolicies/deny-authz-policy-test"
          result: "DENIED"
        }
      ]
      result: "DENIED"
    }
  }
  ...
}

La requête ne correspond pas à la règle DENY, mais correspond à la règle ALLOW.

Lorsqu'une requête ne correspond pas à la règle DENY, l'étape de la règle DENY autorise la requête et l'enregistre en tant que allowed_as_no_deny_policies_matched_request. L'évaluation passe ensuite à l'étape de la règle ALLOW. Comme la requête correspond à la règle ALLOW, l'étape ALLOW consigne le nom de ressource de la règle correspondante dans policies[1].name avec le résultat ALLOWED.

Étant donné que l'étape ALLOW a autorisé la requête, le résultat global (jsonPayload.authzPolicyInfo.result) est consigné comme ALLOWED.

{
  jsonPayload: {
    @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
    authzPolicyInfo: {
      policies: [
        0: {
          details: "allowed_as_no_deny_policies_matched_request"
          result: "ALLOWED"
        }
        1: {
          name: "projects/12345567/locations/global/authzPolicies/allow-authz-policy-test"
          result: "ALLOWED"
        }
      ]
      result: "ALLOWED"
    }
  }
  ...
}

La requête correspond à la règle DENY_BY_DEFAULT

Lorsque vous configurez une règle DENY_BY_DEFAULT sur la règle de transfert d'un équilibreur de charge et qu'aucune règle ALLOW n'est configurée (ou qu'aucune règle CUSTOM n'a autorisé la requête), la requête atteint l'étape d'évaluation du refus par défaut et est bloquée. Cette action est enregistrée en tant que denied_by_default.

{
  jsonPayload: {
    @type: "type.googleapis.com/google.cloud.loadbalancing.type.LoadBalancerLogEntry"
    authzPolicyInfo: {
      policies: [
        {
          details: "denied_by_default",
          result: "DENIED"
        }
      ],
      result: "DENIED"
    }
  }
  ...
}

Configurer des alertes de journal

Vous pouvez configurer des alertes pour les événements que les règles d'autorisation écrivent dans Logging, tels que les refus de trafic ou les correspondances de règles spécifiques. Pour obtenir des instructions générales sur la configuration de ces alertes, consultez Configurer des alertes basées sur les journaux.

Cette section fournit des exemples de requêtes que vous pouvez utiliser pour configurer des alertes pour des événements de stratégie d'autorisation spécifiques. Pour en savoir plus sur les différents noms de journaux et types de ressources pour les équilibreurs de charge, consultez Cloud Load Balancing dans la documentation sur les journaux de la plate-forme.

Le tableau suivant indique le nom du journal et le type de ressource pour différents équilibreurs de charge d'application :

Type d'équilibreur de charge d'application Nom du journal Type de ressource
Équilibreur de charge d'application externe global projects/PROJECT_ID/logs/requests http_load_balancer
Équilibreur de charge d'application externe régional projects/PROJECT_ID/logs/loadbalancing.googleapis.com%2Fexternal_regional_requests http_external_regional_lb_rule
Équilibreur de charge d'application interne régional et équilibreur de charge d'application interne interrégional. projects/PROJECT_ID/logs/loadbalancing.googleapis.com%2Frequests internal_http_lb_rule

Alerte pour le trafic refusé par une règle d'autorisation

Utilisez la requête suivante pour déclencher une alerte lorsqu'une requête est refusée à n'importe quelle étape de l'ordre d'évaluation des règles d'autorisation.

logName: "projects/PROJECT_ID/logs/loadbalancing.googleapis.com%2Fexternal_regional_requests"
resource.type="http_external_regional_lb_rule"
jsonPayload.authzPolicyInfo.result="DENIED"

Alerte pour le trafic refusé, car il ne correspondait à aucune règle ALLOW configurée

Utilisez la requête suivante pour déclencher une alerte lorsqu'une requête est refusée, car elle ne correspond à aucune règle ALLOW configurée :

logName: "projects/PROJECT_ID/logs/loadbalancing.googleapis.com%2Fexternal_regional_requests"
resource.type="http_external_regional_lb_rule"
jsonPayload.authzPolicyInfo.policies.details="denied_as_no_allow_policies_matched_request"

Alerte pour le trafic refusé par une règle DENY_BY_DEFAULT

Utilisez la requête suivante pour déclencher une alerte lorsqu'une règle d'autorisation avec une action DENY_BY_DEFAULT refuse une requête :

logName: "projects/PROJECT_ID/logs/loadbalancing.googleapis.com%2Fexternal_regional_requests"
resource.type="http_external_regional_lb_rule"
(jsonPayload.authzPolicyInfo.policies.details="denied_by_default" OR
jsonPayload.authzPolicyInfo.policies.details="denied_as_no_allow_policies_matched_request")

Étapes suivantes