Cette page a été traduite par l'API Cloud Translation.

Utiliser des règles de pare-feu VPC

Cette page décrit les commandes permettant d'utiliser les règles de pare-feu du cloud privé virtuel (VPC), et propose quelques exemples d'utilisation. Les règles de pare-feu VPC vous permettent d'autoriser ou de refuser le trafic depuis et vers des instances de machines virtuelles (VM) dans un réseau VPC en fonction du numéro de port, du tag ou du protocole.

Avant de commencer

Pour en savoir plus sur les règles de pare-feu VPC, telles que les règles implicites et les règles générées par le système pour les réseaux par défaut, consultez la page Règles de pare-feu VPC.

Avant de configurer les règles de pare-feu, consultez la section Composants des règles de pare-feu pour vous familiariser avec les composants des pare-feu, tels qu'ils sont utilisés dans Google Cloud.

Créer des règles de pare-feu VPC

Les règles de pare-feu VPC sont définies au niveau du réseau et s'appliquent seulement au réseau sur lequel elles ont été créées. Cependant, le nom que vous sélectionnez pour chacune d'elles doit être unique au projet.

Une règle de pare-feu peut contenir des plages IPv4 ou IPv6, mais pas les deux.

Lorsque vous créez une règle de pare-feu, vous pouvez choisir d'activer la journalisation des règles de pare-feu. Si vous activez la journalisation, vous pouvez omettre les champs de métadonnées afin d'économiser les coûts de stockage. Pour plus d'informations, consultez la section Utiliser la journalisation des règles de pare-feu.

Si vous souhaitez spécifier plusieurs comptes de service pour le champ du compte de service cible ou source, utilisez la Google Cloud CLI, l'API ou les bibliothèques clientes.

Le réseau par défaut fournit des règles de pare-feu automatiques au moment de la création. Les réseaux en mode automatique et personnalisé vous permettent de créer facilement des pare-feu similaires lors de la création du réseau si vous utilisez la console Google Cloud. Si vous utilisez gcloud CLI ou l'API, et souhaitez créer des règles de pare-feu similaires à celles fournies par le réseau par défaut, consultez la page Configurer des règles de pare-feu pour les cas d'utilisation courants.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

Console

Dans la console Google Cloud, accédez à la page Règles d'administration.

Accéder à la page "Stratégies de pare-feu"
Cliquez sur Créer une règle de pare-feu.
Entrez un nom pour la règle de pare-feu.

Ce nom doit être unique au projet.
(Facultatif) Vous pouvez activer la journalisation des règles de pare-feu :
- Cliquez sur Journaux > Activé.
- Pour omettre les métadonnées, cliquez sur Afficher les détails des journaux, puis décochez la case Inclure les métadonnées.
Spécifiez le réseau pour la règle de pare-feu.
Spécifiez la priorité de la règle.

Plus la valeur est faible, plus la priorité est élevée.
Sélectionnez Entrée ou Sortie pour l'option Direction du trafic.
Sélectionnez Autoriser ou Refuser pour l'option Action en cas de correspondance.
Spécifiez les cibles de la règle.
- Si vous souhaitez que la règle s'applique à toutes les instances du réseau, sélectionnez All instances in the network (Toutes les instances du réseau).
- Si vous souhaitez que la règle s'applique à des instances spécifiques en fonction de tags réseau (cibles), sélectionnez Tags cibles spécifiés, puis, dans le champ Tags cibles, saisissez les tags auxquels la règle doit s'appliquer.
- Si vous souhaitez que la règle s'applique à des instances spécifiques en fonction du compte de service associé, sélectionnez Compte de service spécifié, indiquez si le compte de service se trouve dans le projet en cours ou dans un autre dans le champ d'application du compte de service puis, dans le champ Compte de service cible, sélectionnez ou saisissez le nom du compte de service.
Pour une règle d'entrée, spécifiez le filtre source :
- Pour filtrer le trafic entrant par plages IPv4 sources, sélectionnez Plages IPv4, puis saisissez les blocs CIDR dans le champ Plages IPv4 sources. Utilisez 0.0.0.0/0 pour n'importe quelle source IPv4.
- Pour filtrer le trafic entrant par plages IPv6 sources, sélectionnez Plages IPv6, puis saisissez les blocs CIDR dans le champ Plages IPv6 sources. Utilisez ::/0 pour n'importe quelle source IPv6.
- Pour filtrer le trafic entrant par tag réseau, sélectionnez Tags sources, puis saisissez les tags réseau dans le champ Tags sources. Pour connaître le nombre maximal de tags sources, consultez la section Limites par réseau. Le filtrage par tag source n'est disponible que si la cible n'est pas spécifiée par compte de service. Pour en savoir plus, consultez la section Filtrer par compte de service ou par tag réseau.
- Pour filtrer le trafic entrant par compte de service, sélectionnez Compte de service, puis indiquez si le compte de service se trouve dans le projet en cours ou dans un autre projet dans le champ d'application du compte de service. Choisissez ou saisissez ensuite le nom du compte de service dans le champ Compte de service source. Le filtrage par compte de service source n'est disponible que si la cible n'est pas spécifiée par tag réseau. Pour en savoir plus, consultez la section Filtrer par compte de service ou par tag réseau.
- Si vous le souhaitez, définissez un Deuxième filtre source. Ces types de filtre ne peuvent pas utiliser les mêmes critères de filtrage que les filtres principaux. Les plages d'adresses IP sources peuvent être utilisées avec les tags sources ou les comptes de service sources. L'ensemble de sources utilisé correspond à la combinaison des plages d'adresses IP sources et des instances identifiées par des tags réseau ou des comptes de service. En d'autres termes, si la plage d'adresses IP sources ou les tags sources (ou les comptes de service sources) correspondent aux critères de filtrage, la source est incluse dans l'ensemble de sources effectif.
- Les tags sources et les comptes de service sources ne peuvent pas être utilisés conjointement.
Pour une règle d'entrée, spécifiez le filtre de destination :
- Pour filtrer le trafic entrant par plages IPv4 de destination, sélectionnez Plages IPv4 et saisissez les blocs CIDR dans le champ Plages IPv4 de destination. Utilisez 0.0.0.0/0 pour n'importe quelle destination IPv4.
- Pour filtrer le trafic entrant par plages IPv6 de destination, sélectionnez Plages IPv6 et saisissez les blocs CIDR dans le champ Plages IPv6 de destination. Utilisez ::/0 pour n'importe quelle destination IPv6. Pour en savoir plus, consultez la section Destination des règles d'entrée.
Pour une règle de sortie, spécifiez le Filtre de destination :
- Pour filtrer le trafic sortant par plages IPv4 de destination, sélectionnez Plages IPv4 et saisissez les blocs CIDR dans le champ Plages IPv4 de destination. Utilisez 0.0.0.0/0 pour n'importe quelle destination IPv4.
- Pour filtrer le trafic sortant par plages IPv6 de destination, sélectionnez Plages IPv6 et saisissez les blocs CIDR dans le champ Plages IPv6 de destination. Utilisez ::/0 pour n'importe quelle destination IPv6.
Pour une règle de sortie, spécifiez le filtre de source :
- Pour filtrer le trafic sortant par plages IPv4 sources, sélectionnez Plages IPv4, puis saisissez les blocs CIDR dans le champ Plages IPv4 sources. Utilisez 0.0.0.0/0 pour n'importe quelle source IPv4.
- Pour filtrer le trafic sortant par plages IPv6 sources, sélectionnez Plages IPv6, puis saisissez les blocs CIDR dans le champ Plages IPv6 sources. Utilisez ::/0 pour n'importe quelle destination IPv6. Pour en savoir plus, consultez la section Source pour les règles de sortie.
Définissez les Protocoles et ports auxquels la règle s'applique :
- Pour que la règle s'applique à tous les protocoles et ports de destination, sélectionnez Tout autoriser ou Tout refuser, selon l'action à effectuer.
- Pour définir des protocoles et des ports de destination spécifiques, sélectionnez Protocoles et ports spécifiés :
  - Sélectionnez TCP pour inclure le protocole et les ports de destination TCP. Saisissez all ou une liste de ports de destination délimités par des virgules, telle que 20-22, 80, 8080.
  - Sélectionnez UDP pour inclure le protocole et les ports de destination UDP. Saisissez all ou une liste de ports de destination délimités par des virgules, telle que 67-69, 123.
  - Sélectionnez Autres protocoles pour inclure des protocoles tels que icmp et sctp, ou un numéro de protocole. Par exemple, utilisez icmp ou le numéro de protocole 1 pour IPv4 ICMP. Utilisez le numéro de protocole 58 pour IPv6 ICMP.
    
    Pour en savoir plus, consultez la section Protocoles et ports de destination.
(Facultatif) Vous pouvez créer la règle de pare-feu sans l'activer en définissant son état d'application sur désactivée. Cliquez sur Désactiver la règle, puis sélectionnez Désactivée.
Cliquez sur Créer.

gcloud

Pour créer une règle de pare-feu VPC, exécutez la commande gcloud compute firewall-rules create :

gcloud compute firewall-rules create RULE_NAME \
    [--network NETWORK; default="default"] \
    [--priority PRIORITY;default=1000] \
    [--direction (ingress|egress|in|out); default="ingress"] \
    [--action (deny | allow )] \
    [--target-tags TAG[,TAG,...]] \
    [--target-service-accounts=IAM_SERVICE_ACCOUNT[,IAM_SERVICE_ACCOUNT,...]] \
    [--source-ranges CIDR_RANGE[,CIDR_RANGE,...]] \
    [--source-tags TAG,TAG,] \
    [--source-service-accounts=IAM_SERVICE_ACCOUNT[,IAM_SERVICE_ACCOUNT,...]] \
    [--destination-ranges CIDR_RANGE[,CIDR_RANGE,...]] \
    [--rules (PROTOCOL[:PORT[-PORT]],[PROTOCOL[:PORT[-PORT]],...]] | all ) \
    [--disabled | --no-disabled] \
    [--enable-logging | --no-enable-logging] \
    [--logging-metadata LOGGING_METADATA]

Utilisez les paramètres en fonction des explications ci-dessous. Des informations plus détaillées sur chacun des paramètres sont disponibles dans la Documentation de référence du SDK.

--network Réseau associé à la règle. S'il n'est pas renseigné, la règle est créée dans le réseau default. Si vous n'avez pas de réseau par défaut ou si vous souhaitez créer la règle dans un réseau spécifique, vous devez utiliser ce champ.
Le paramètre --priority est une valeur numérique indiquant la priorité de la règle. Plus la valeur est faible, plus la priorité est élevée.
Le paramètre --direction indique le sens du trafic. Il peut être défini sur ingress (entrée) ou egress (sortie).
Le paramètre --action indique l'action en cas de correspondance. Il peut être défini sur allow (autoriser) ou deny (refuser), et doit être utilisé avec l'option --rules (règles).
Vous pouvez spécifier une cible de l'une des manières suivantes :
- Ne renseignez pas les options --target-tags (tags cibles) et --target-service-accounts (comptes de service cibles) si la règle doit s'appliquer à toutes les cibles du réseau.
- Utilisez l'option --target-tags pour définir des cibles par tags réseau.
- Utilisez l'option --target-service-accounts pour définir des cibles par comptes de service associés.
Pour la règle d'entrée, pour affiner davantage la destination, utilisez --destination-ranges pour spécifier les plages d'adresses IPv4 ou IPv6 au format CIDR. Si l'élément --destination-ranges est omis, la destination d'entrée est n'importe quelle adresse IPv4, 0.0.0.0/0. Pour plus d'informations, consultez les sections Destinations pour les règles d'entrée et Adresses IP et cibles pour les règles d'entrée.
Pour une règle d'entrée, spécifiez une source :
- Utilisez l'option --source-ranges (plages sources) pour spécifier des plages d'adresses IPv4 ou IPv6 sources au format CIDR.
- Si les éléments --source-ranges, source-tags et --source-service-accounts sont omis, la source d'entrée est toute adresse IPv4, 0.0.0.0/0.
- Utilisez l'option --source-tags (tags sources) pour spécifier les instances sources par tags réseau. Le filtrage par tag source n'est disponible que si la cible n'est pas spécifiée par compte de service. Pour en savoir plus, consultez la section Filtrer par compte de service ou par tag réseau.
- Les options --source-ranges (plages sources) et --source-tags (tags sources) peuvent être utilisées conjointement. Si les deux options sont spécifiées, l'ensemble de sources utilisé correspond à la combinaison des plages d'adresses IP sources et des instances identifiées à l'aide des tags réseau, même si les instances avec tag ne disposent pas d'adresses IP dans les plages sources.
- Utilisez l'option --source-service-accounts (comptes de service sources) pour spécifier des instances en fonction des comptes de service qu'elles utilisent. Le filtrage par compte de service source n'est disponible que si la cible n'est pas spécifiée par tag réseau. Pour en savoir plus, consultez la section Filtrer par compte de service ou par tag réseau. Les options --source-ranges (plages sources) et --source-service-accounts (comptes de service sources) peuvent être utilisées conjointement. Si les deux sont spécifiés, l'ensemble de sources utilisé correspond à la combinaison des plages d'adresses IP sources et des instances identifiées par les comptes de service sources, même si les instances identifiées par les comptes de service sources ne contiennent pas d'adresses IP dans les plages sources.
Pour la règle de sortie, pour affiner davantage la source, utilisez --source-ranges pour spécifier des plages d'adresses IPv4 ou IPv6 au format CIDR. Si l'élément --source-ranges est omis, la source de sortie est n'importe quelle adresse IPv4, 0.0.0.0/0. Pour en savoir plus, consultez les pages Sources pour les règles de sortie et Cibles et adresses IP pour les règles de sortie.
Pour une règle de sortie, spécifiez une destination :
- Utilisez l'option --destination-ranges (plages sources) pour spécifier des plages d'adresses IPv4 ou IPv6 sources au format CIDR.
- Si l'élément --destination-ranges est omis, la destination de sortie est n'importe quelle adresse IPv4, 0.0.0.0/0.
--rules Liste des protocoles et ports de destination auxquels la règle s'applique. Sélectionnez all (tous) pour appliquer la règle à tous les protocoles et à tous les ports de destination. Ce paramètre nécessite l'option --action.
Par défaut, les règles de pare-feu sont créées et appliquées automatiquement. Cependant, vous pouvez modifier ce comportement.
- Si les options --disabled (désactivée) et --no-disabled (non désactivée) ne sont pas sélectionnées, la règle de pare-feu est créée et appliquée.
- Ajoutez l'option --disabled (désactivée) pour créer la règle de pare-feu sans l'appliquer. La règle de pare-feu reste désactivée jusqu'à la mise à jour de la règle de pare-feu, qui permet de l'activer.
- Ajoutez l'option --no-disabled (non désactivée) si vous souhaitez appliquer la règle de pare-feu.
--enable-logging | --no-enable-loggingVous pouvez activer la journalisation des règles de pare-feu lors de la création ou de la mise à jour d'une règle. La journalisation des règles de pare-feu vous permet de réaliser des audits, des vérifications et des analyses sur les effets de vos règles de pare-feu. Pour en savoir plus, consultez la section Journalisation des règles de pare-feu.
- --logging-metadata Si vous activez la journalisation, la journalisation des règles de pare-feu inclut par défaut les champs de base et de métadonnées. Vous pouvez omettre les champs de métadonnées pour réduire les coûts de stockage. Pour plus d'informations, consultez la section Utiliser la journalisation des règles de pare-feu.

Terraform

Pour créer une règle de pare-feu, vous pouvez utiliser une ressource google_compute_firewall.

resource "google_compute_firewall" "rules" {
  name        = "my-firewall-rule"
  network     = "default"
  description = "Creates firewall rule targeting tagged instances"

  allow {
    protocol = "tcp"
    ports    = ["80", "443"]
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["web"]
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

API

Créez une règle de pare-feu VPC.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "RULE_NAME",
  "network": "projects/PROJECT-ID/global/networks/NETWORK",
  ... other fields
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet où se trouve le réseau VPC.
NETWORK : nom du réseau VPC dans lequel la règle de pare-feu est créée.
RULE_NAME : nom de la règle de pare-feu.
Pour une règle de pare-feu d'entrée, spécifiez la source et la destination de l'entrée :
- Utilisez les champs sourceRanges, sourceTags ou sourceServiceAccounts pour spécifier la source d'entrée.
- sourceRanges peut être des plages IPv4 ou IPv6, mais pas à une combinaison des deux. Pour utiliser la plage 0.0.0.0/0, ne spécifiez aucun champ.
- Vous ne pouvez pas utiliser conjointement les champs sourceTags et sourceServiceAccounts. Cependant, vous pouvez associer sourceRanges avec sourceTags ou sourceServiceAccounts. Dans ce cas, la connexion doit simplement correspondre à l'un ou l'autre des champs pour que la règle de pare-feu s'applique.
- Pour les champs cibles, vous ne pouvez pas utiliser le champ targetServiceAccounts si vous utilisez le champ sourceTags. Vous devez soit utiliser le champ targetTags, soit aucun champ cible. De même, si vous spécifiez le champ sourceServiceAccounts, vous ne pouvez pas utiliser le champ targetTags. Si vous ne spécifiez pas de champ cible, la règle s'applique à toutes les cibles du réseau.
- Utilisez le champ destinationRanges pour spécifier la destination d'entrée. destinationRanges peut être des plages IPv4 ou IPv6, mais pas à une combinaison des deux.
  Si vous ne spécifiez pas de destination, Google Cloud utilise 0.0.0.0/0. Pour en savoir plus, consultez les pages Destinations pour les règles d'entrée et Cibles et adresses IP pour les règles d'entrée.
Pour une règle de pare-feu de sortie, spécifiez la source et la destination des sorties :
- Utilisez le champ sourceRanges pour spécifier la source de sortie. sourceRange peut être des plages IPv4 ou IPv6, mais pas une combinaison des deux.
  Si vous ne spécifiez pas de source, Google Cloud utilise 0.0.0.0/0. Pour en savoir plus, consultez les pages Sources pour les règles de sortie et Cibles et adresses IP pour les règles de sortie.
- Utilisez le champ destinationRanges pour spécifier la destination. destinationRanges peut être des plages IPv4 ou IPv6, mais pas une combinaison des deux.
  Si vous ne spécifiez pas de destination, Google Cloud utilise 0.0.0.0/0. Définissez le champ targetTags ou targetServiceAccounts pour spécifier les cibles auxquelles la règle s'applique. Si vous ne spécifiez pas de champ cible, la règle s'applique à toutes les cibles du réseau.

Pour obtenir plus d'informations et la description de chaque champ, reportez-vous à la méthode firewalls.insert.

C#


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class CreateFirewallRuleAsyncSample
{
    public async Task CreateFirewallRuleAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string firewallRuleName = "my-test-firewall-rule",
        // Name of the network the rule will be applied to. Some available name formats:
        // projects/{project_id}/global/networks/{network}
        // global/networks/{network}
        string networkName = "global/networks/default")
    {
        Firewall firewallRule = new Firewall
        {
            Name = firewallRuleName,
            Network = networkName,
            Direction = ComputeEnumConstants.Firewall.Direction.Ingress,
            Allowed =
            {
                new Allowed
                {
                    Ports = { "80", "443" },
                    IPProtocol = "tcp"
                }
            },
            TargetTags = { "web" },
            Description = "Allows TCP traffic on port 80 and 443 from anywhere."
        };

        // Note that the default value of priority for the firewall API is 1000.
        // If you check the value of firewallRule.Priority at this point it
        // will be equal to 0, however it is not treated as "set" by the library, and thus
        // the default will be applied to the new rule. If you want to create a rule that
        // has priority == 0, you'll need to explicitly set it: firewallRule.Priority = 0.
        // You can use the firewallRule.HasPriority property to check if the priority has been set.
        // You can use the firewallRule.ClearPriority() method to unset the priority.

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        FirewallsClient client = await FirewallsClient.CreateAsync();

        // Create the firewall rule in the specified project.
        var firewallRuleCreation = await client.InsertAsync(projectId, firewallRule);

        // Wait for the operation to complete using client-side polling.
        await firewallRuleCreation.PollUntilCompletedAsync();
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createFirewallRule creates a firewall rule allowing for incoming HTTP and HTTPS access from the entire Internet.
func createFirewallRule(w io.Writer, projectID, firewallRuleName, networkName string) error {
	// projectID := "your_project_id"
	// firewallRuleName := "europe-central2-b"
	// networkName := "global/networks/default"

	ctx := context.Background()
	firewallsClient, err := compute.NewFirewallsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer firewallsClient.Close()

	firewallRule := &computepb.Firewall{
		Allowed: []*computepb.Allowed{
			{
				IPProtocol: proto.String("tcp"),
				Ports:      []string{"80", "443"},
			},
		},
		Direction: proto.String(computepb.Firewall_INGRESS.String()),
		Name:      &firewallRuleName,
		TargetTags: []string{
			"web",
		},
		Network:     &networkName,
		Description: proto.String("Allowing TCP traffic on port 80 and 443 from Internet."),
	}

	// Note that the default value of priority for the firewall API is 1000.
	// If you check the value of `firewallRule.GetPriority()` at this point it
	// will be equal to 0, however it is not treated as "set" by the library and thus
	// the default will be applied to the new rule. If you want to create a rule that
	// has priority == 0, you need to explicitly set it so:

	// firewallRule.Priority = proto.Int32(0)

	req := &computepb.InsertFirewallRequest{
		Project:          projectID,
		FirewallResource: firewallRule,
	}

	op, err := firewallsClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create firewall rule: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Firewall rule created\n")

	return nil
}

Java


import com.google.cloud.compute.v1.Allowed;
import com.google.cloud.compute.v1.Firewall;
import com.google.cloud.compute.v1.Firewall.Direction;
import com.google.cloud.compute.v1.FirewallsClient;
import com.google.cloud.compute.v1.InsertFirewallRequest;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateFirewallRule {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample
    /* project: project ID or project number of the Cloud project you want to use.
       firewallRuleName: name of the rule that is created.
       network: name of the network the rule will be applied to. Available name formats:
        * https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
        * projects/{project_id}/global/networks/{network}
        * global/networks/{network} */
    String project = "your-project-id";
    String firewallRuleName = "firewall-rule-name-" + UUID.randomUUID();
    String network = "global/networks/default";

    // The rule will be created with default priority of 1000.
    createFirewall(project, firewallRuleName, network);
  }

  // Creates a simple firewall rule allowing for incoming HTTP and 
  // HTTPS access from the entire Internet.
  public static void createFirewall(String project, String firewallRuleName, String network)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `firewallsClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (FirewallsClient firewallsClient = FirewallsClient.create()) {

      // The below firewall rule is created in the default network.
      Firewall firewallRule = Firewall.newBuilder()
          .setName(firewallRuleName)
          .setDirection(Direction.INGRESS.toString())
          .addAllowed(
              Allowed.newBuilder().addPorts("80").addPorts("443").setIPProtocol("tcp").build())
          .addSourceRanges("0.0.0.0/0")
          .setNetwork(network)
          .addTargetTags("web")
          .setDescription("Allowing TCP traffic on port 80 and 443 from Internet.")
          .build();

      /* Note that the default value of priority for the firewall API is 1000.
         If you check the value of `firewallRule.getPriority()` at this point it
         will be equal to 0, however it is not treated as "set" by the library and thus
         the default will be applied to the new rule. If you want to create a rule that
         has priority == 0, you'll need to explicitly set it so: setPriority(0) */

      InsertFirewallRequest insertFirewallRequest = InsertFirewallRequest.newBuilder()
          .setFirewallResource(firewallRule)
          .setProject(project).build();

      firewallsClient.insertAsync(insertFirewallRequest).get(3, TimeUnit.MINUTES);

      System.out.println("Firewall rule created successfully -> " + firewallRuleName);
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const firewallRuleName = 'YOUR_FIREWALL_RULE_NAME'
// const networkName = 'global/networks/default'

const compute = require('@google-cloud/compute');
const computeProtos = compute.protos.google.cloud.compute.v1;

async function createFirewallRule() {
  const firewallsClient = new compute.FirewallsClient();
  const operationsClient = new compute.GlobalOperationsClient();

  const firewallRule = new computeProtos.Firewall();
  firewallRule.name = firewallRuleName;
  firewallRule.direction = 'INGRESS';
  firewallRule.allowed = [
    {
      IPProtocol: 'tcp',
      ports: ['80', '443'],
    },
  ];
  firewallRule.targetTags = ['web'];
  firewallRule.network = networkName;
  firewallRule.description =
    'Allowing TCP traffic on port 80 and 443 from Internet.';

  // Note that the default value of priority for the firewall API is 1000.
  // If you check the value of `firewallRule.priority` at this point it
  // will be equal to null, however it is not treated as "set" by the library and thus
  // the default will be applied to the new rule. If you want to create a rule that
  // has priority == 0, you need to explicitly set it so:

  // firewallRule.priority = 0

  const [response] = await firewallsClient.insert({
    project: projectId,
    firewallResource: firewallRule,
  });
  let operation = response.latestResponse;

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
    });
  }

  console.log('Firewall rule created');
}

createFirewallRule();

PHP

use Google\Cloud\Compute\V1\Allowed;
use Google\Cloud\Compute\V1\Client\FirewallsClient;
use Google\Cloud\Compute\V1\Enums\Firewall\Direction;

/**
 * To correctly handle string enums in Cloud Compute library
 * use constants defined in the Enums subfolder.
 */
use Google\Cloud\Compute\V1\Firewall;
use Google\Cloud\Compute\V1\InsertFirewallRequest;

/**
 * Creates a simple firewall rule allowing incoming HTTP and HTTPS access from the entire internet.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to create a rule for.
 * @param string $firewallRuleName Name of the rule that is created.
 * @param string $network Name of the network the rule will be applied to. Available name formats:
 *                        https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
 *                        projects/{project_id}/global/networks/{network}
 *                        global/networks/{network}
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */

function create_firewall_rule(string $projectId, string $firewallRuleName, string $network = 'global/networks/default')
{
    $firewallsClient = new FirewallsClient();
    $allowedPorts = (new Allowed())
      ->setIPProtocol('tcp')
      ->setPorts(['80', '443']);
    $firewallResource = (new Firewall())
      ->setName($firewallRuleName)
      ->setDirection(Direction::INGRESS)
      ->setAllowed([$allowedPorts])
      ->setSourceRanges(['0.0.0.0/0'])
      ->setTargetTags(['web'])
      ->setNetwork($network)
      ->setDescription('Allowing TCP traffic on ports 80 and 443 from Internet.');

    /**
    * Note that the default value of priority for the firewall API is 1000.
    * If you check the value of its priority at this point it will be
    * equal to 0, however it is not treated as "set" by the library and thus
    * the default will be applied to the new rule. If you want to create a rule
    * that has priority == 0, you need to explicitly set it so:
    *
    *   $firewallResource->setPriority(0);
    */

    //Create the firewall rule using Firewalls Client.
    $request = (new InsertFirewallRequest())
        ->setFirewallResource($firewallResource)
        ->setProject($projectId);
    $operation = $firewallsClient->insert($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Created rule %s.' . PHP_EOL, $firewallRuleName);
    } else {
        $error = $operation->getError();
        printf('Firewall rule creation failed: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_firewall_rule(
    project_id: str, firewall_rule_name: str, network: str = "global/networks/default"
) -> compute_v1.Firewall:
    """
    Creates a simple firewall rule allowing for incoming HTTP and HTTPS access from the entire Internet.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        firewall_rule_name: name of the rule that is created.
        network: name of the network the rule will be applied to. Available name formats:
            * https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
            * projects/{project_id}/global/networks/{network}
            * global/networks/{network}

    Returns:
        A Firewall object.
    """
    firewall_rule = compute_v1.Firewall()
    firewall_rule.name = firewall_rule_name
    firewall_rule.direction = "INGRESS"

    allowed_ports = compute_v1.Allowed()
    allowed_ports.I_p_protocol = "tcp"
    allowed_ports.ports = ["80", "443"]

    firewall_rule.allowed = [allowed_ports]
    firewall_rule.source_ranges = ["0.0.0.0/0"]
    firewall_rule.network = network
    firewall_rule.description = "Allowing TCP traffic on port 80 and 443 from Internet."

    firewall_rule.target_tags = ["web"]

    # Note that the default value of priority for the firewall API is 1000.
    # If you check the value of `firewall_rule.priority` at this point it
    # will be equal to 0, however it is not treated as "set" by the library and thus
    # the default will be applied to the new rule. If you want to create a rule that
    # has priority == 0, you need to explicitly set it so:
    # TODO: Uncomment to set the priority to 0
    # firewall_rule.priority = 0

    firewall_client = compute_v1.FirewallsClient()
    operation = firewall_client.insert(
        project=project_id, firewall_resource=firewall_rule
    )

    wait_for_extended_operation(operation, "firewall rule creation")

    return firewall_client.get(project=project_id, firewall=firewall_rule_name)

Ruby


require "google/cloud/compute/v1"

# Creates a simple firewall rule allowing for incoming HTTP and HTTPS access from the entire Internet.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] name: name of the rule that is created.
# @param network: name of the network the rule will be applied to. Available name formats:
#         * https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
#         * projects/{project_id}/global/networks/{network}
#         * global/networks/{network}
def create_firewall_rule project:, name:, network: "global/networks/default"
  rule = {
    name: name,
    direction: "INGRESS",
    allowed: [{
      I_p_protocol: "tcp",
      ports: ["80", "443"]
    }],
    source_ranges: ["0.0.0.0/0"],
    network: network,
    description: "Allowing TCP traffic on port 80 and 443 from Internet.",
    target_tags: ["web"]
  }

  # Note that the default value of priority for the firewall API is 1000.
  # If you want to create a rule that has priority == 0, you need to explicitly set it:
  #   rule[:priority] = 0
  # Use `rule.has_key? :priority` to check if the priority has been set.
  # Use `rule.delete :priority` method to unset the priority.

  request = {
    firewall_resource: rule,
    project: project
  }

  client = ::Google::Cloud::Compute::V1::Firewalls::Rest::Client.new
  operation = client.insert request

  wait_until_done operation: operation
end

Mettre à jour des règles de pare-feu VPC

Vous pouvez modifier certains composants d'une règle de pare-feu VPC, tels que les protocoles et ports de destination spécifiés pour la condition de correspondance. Néanmoins, vous ne pouvez pas modifier son nom, son réseau, l'action en cas de correspondance et le sens du trafic.

Si vous devez modifier le nom, le réseau, l'action ou le sens, vous devez supprimer la règle et en créer une autre.

Si vous souhaitez ajouter ou supprimer plusieurs comptes de service, utilisez Google Cloud CLI, l'API ou les bibliothèques clientes. Vous ne pouvez pas utiliser la console Google Cloud pour spécifier plusieurs comptes de service cibles ou sources.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.update

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

Console

Dans la console Google Cloud, accédez à la page Règles d'administration.

Accéder à la page "Stratégies de pare-feu"
Cliquez sur la règle que vous souhaitez modifier.
Cliquez sur Modifier.
Modifiez l'un des composants modifiables selon vos besoins.
Cliquez sur Enregistrer.

gcloud

Pour mettre à jour des règles de pare-feu VPC, exécutez la commande gcloud compute firewall-rules update :

gcloud compute firewall-rules update RULE_NAME \
    [--priority=PRIORITY] \
    [--description=DESCRIPTION] \
    [--target-tags=TAG,...] \
    [--target-service-accounts=IAM_SERVICE_ACCOUNT,_] \
    [--source-ranges=CIDR_RANGE,...] \
    [--source-tags=TAG,...] \
    [--source-service-accounts=IAM_SERVICE_ACCOUNT,_] \
    [--destination-ranges=CIDR_RANGE,...] \
    [--rules=[PROTOCOL[:PORT[-PORT]],…]] \
    [--disabled | --no-disabled] \
    [--enable-logging | --no-enable-logging]

Les descriptions de chaque option sont identiques à celles utilisées pour créer des règles de pare-feu. Vous trouverez plus d'informations sur chacune d'elles dans la documentation de référence du SDK.

API

Envoyez une requête PATCH pour mettre à jour les champs suivants : allowed, description, sourceRanges, sourceTags ou targetTags. Envoyez une requête PUT ou POST pour tous les autres champs.

(PATCH|(POST|PUT)) https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls/RULE_NAME
{
  "name": "RULE_NAME",
  "network": "projects/PROJECT-ID/global/networks/NETWORK",
  ... other fields
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet où se trouve le réseau VPC.
NETWORK : nom du réseau VPC où se trouve la règle de pare-feu.
RULE_NAME : nom de la règle de pare-feu à mettre à jour.

Pour obtenir plus d'informations et la description de chaque champ, reportez-vous à la méthode firewalls.patch ou firewalls.update.

C#


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class PatchFirewallRuleAsyncSample
{
    public async Task PatchFirewallRuleAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string firewallRuleName = "my-test-firewall-rule",
        int newPriority = 10)
    {
        // The patch operation doesn't require the full definition of a Firewall object.
        // It will only update the values that were set in it,
        // in this case it will only change the priority.
        Firewall firewallRule = new Firewall
        {
            Priority = newPriority
        };

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        FirewallsClient client = await FirewallsClient.CreateAsync();

        // Patch the firewall rule in the specified project.
        var firewallRulePatching = await client.PatchAsync(projectId, firewallRuleName, firewallRule);

        // Wait for the operation to complete using client-side polling.
        await firewallRulePatching.PollUntilCompletedAsync();
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// patchFirewallPriority modifies the priority of a given firewall rule.
func patchFirewallPriority(w io.Writer, projectID, firewallRuleName string, priority int32) error {
	// projectID := "your_project_id"
	// firewallRuleName := "europe-central2-b"
	// priority := 10

	ctx := context.Background()
	firewallsClient, err := compute.NewFirewallsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer firewallsClient.Close()

	firewallRule := &computepb.Firewall{
		Priority: proto.Int32(priority),
	}

	req := &computepb.PatchFirewallRequest{
		Project:          projectID,
		Firewall:         firewallRuleName,
		FirewallResource: firewallRule,
	}

	// The patch operation doesn't require the full definition of a Firewall interface. It will only update
	// the values that were set in it, in this case it will only change the priority.
	op, err := firewallsClient.Patch(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to patch firewall rule: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Firewall rule updated\n")

	return nil
}

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.Firewall;
import com.google.cloud.compute.v1.FirewallsClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.PatchFirewallRequest;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class PatchFirewallRule {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample
    // project: project ID or project number of the Cloud project you want to use.
    // firewallRuleName: name of the rule you want to modify.
    // priority: the new priority to be set for the rule.
    String project = "your-project-id";
    String firewallRuleName = "firewall-rule-name-" + UUID.randomUUID();
    int priority = 10;

    patchFirewallPriority(project, firewallRuleName, priority);
  }

  // Modifies the priority of a given firewall rule.
  public static void patchFirewallPriority(String project, String firewallRuleName, int priority)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `firewallsClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (FirewallsClient firewallsClient = FirewallsClient.create()) {

      /* The patch operation doesn't require the full definition of a Firewall object. It will only 
         update the values that were set in it, in this case it will only change the priority. */
      Firewall firewall = Firewall.newBuilder()
          .setPriority(priority).build();

      PatchFirewallRequest patchFirewallRequest = PatchFirewallRequest.newBuilder()
          .setProject(project)
          .setFirewall(firewallRuleName)
          .setFirewallResource(firewall).build();

      OperationFuture<Operation, Operation> operation = firewallsClient.patchAsync(
          patchFirewallRequest);
      operation.get(3, TimeUnit.MINUTES);
      System.out.println("Firewall Patch applied successfully ! ");
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const firewallRuleName = 'FIREWALL_RULE_NAME';
// const priority = 10;

const compute = require('@google-cloud/compute');
const computeProtos = compute.protos.google.cloud.compute.v1;

async function patchFirewallPriority() {
  const firewallsClient = new compute.FirewallsClient();
  const operationsClient = new compute.GlobalOperationsClient();

  const firewallRule = new computeProtos.Firewall();
  firewallRule.priority = priority;

  // The patch operation doesn't require the full definition of a Firewall object. It will only update
  // the values that were set in it, in this case it will only change the priority.
  const [response] = await firewallsClient.patch({
    project: projectId,
    firewall: firewallRuleName,
    firewallResource: firewallRule,
  });
  let operation = response.latestResponse;

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
    });
  }

  console.log('Firewall rule updated');
}

patchFirewallPriority();

PHP

use Google\Cloud\Compute\V1\Client\FirewallsClient;
use Google\Cloud\Compute\V1\Firewall;
use Google\Cloud\Compute\V1\PatchFirewallRequest;

/**
 * Modifies the priority of a given firewall rule.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to patch a rule from.
 * @param string $firewallRuleName Name of the rule that you want to modify.
 * @param int $priority The new priority to be set for the rule.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function patch_firewall_priority(string $projectId, string $firewallRuleName, int $priority)
{
    $firewallsClient = new FirewallsClient();
    $firewallResource = (new Firewall())->setPriority($priority);

    // The patch operation doesn't require the full definition of a Firewall object. It will only update
    // the values that were set in it, in this case it will only change the priority.
    $request = (new PatchFirewallRequest())
        ->setFirewall($firewallRuleName)
        ->setFirewallResource($firewallResource)
        ->setProject($projectId);
    $operation = $firewallsClient->patch($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Patched %s priority to %d.' . PHP_EOL, $firewallRuleName, $priority);
    } else {
        $error = $operation->getError();
        printf('Patching failed: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def patch_firewall_priority(
    project_id: str, firewall_rule_name: str, priority: int
) -> None:
    """
    Modifies the priority of a given firewall rule.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        firewall_rule_name: name of the rule you want to modify.
        priority: the new priority to be set for the rule.
    """
    firewall_rule = compute_v1.Firewall()
    firewall_rule.priority = priority

    # The patch operation doesn't require the full definition of a Firewall object. It will only update
    # the values that were set in it, in this case it will only change the priority.
    firewall_client = compute_v1.FirewallsClient()
    operation = firewall_client.patch(
        project=project_id, firewall=firewall_rule_name, firewall_resource=firewall_rule
    )

    wait_for_extended_operation(operation, "firewall rule patching")

Ruby


require "google/cloud/compute/v1"

# Modifies the priority of a given firewall rule.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] name name of the rule you want to modify.
# @param [Google::Protobuf::RepeatedField] allowed the repeated instances of the Allowed field in the rule.
#         Compute errors out if allowed is empty.
# @param [Integer] priority the new priority to be set for the rule.
def patch_firewall_priority project:, name:, allowed:, priority:
  allowed_arr = allowed.map do |instance|
    {
      I_p_protocol: instance.I_p_protocol,
      ports: instance.ports.to_a
    }
  end.to_a

  rule = {
    priority: priority,
    allowed: allowed_arr
  }

  request = {
    project: project,
    firewall: name,
    firewall_resource: rule
  }

  # The patch operation doesn't require the full definition of a Firewall object. It will only update
  # the values that were set in it, in this case it will only change the priority.
  client = ::Google::Cloud::Compute::V1::Firewalls::Rest::Client.new
  operation = client.patch request

  wait_until_done operation: operation
end

Répertorier les règles de pare-feu VPC d'un réseau VPC

Vous pouvez répertorier toutes les règles de pare-feu VPC de votre projet ou d'un réseau VPC particulier. Pour chaque règle de pare-feu, Google Cloud affiche des détails tels que le type, les cibles et les filtres de la règle.

Si vous activez la journalisation des règles de pare-feu, Firewall Insights peut fournir des insights sur vos règles de pare-feu afin de vous aider à mieux comprendre et optimiser en toute sécurité leurs configurations. Par exemple, vous pouvez afficher quelles règles allow n'ont pas été utilisées au cours des six dernières semaines. Pour en savoir plus, consultez la section sur l'utilisation de l'écran de détails des règles de pare-feu dans la documentation Firewall Insights.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.list

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)
Administrateur de réseaux Compute (roles/compute.networkAdmin)
Lecteur de réseau Compute (roles/compute.networkViewer)
Lecteur de Compute (roles/compute.viewer)

Console

Pour afficher toutes les règles de pare-feu VPC pour l'ensemble des réseaux de votre projet, procédez comme suit :

Dans la console Google Cloud, accédez à la page Règles d'administration.

Accéder à la page "Stratégies de pare-feu"

Pour afficher les règles de pare-feu VPC d'un réseau particulier, procédez comme suit :

Dans la console Google Cloud, accédez à la page Réseaux VPC.

Accéder aux réseaux VPC
Cliquez sur le nom d'un réseau VPC pour accéder à sa page de détails.
Sur la page de détails du réseau, cliquez sur l'onglet Pare-feu.
Développez vpc-firewall-rules.

gcloud

Pour générer une liste triée des règles de pare-feu VPC pour un réseau donné, exécutez la commande gcloud compute firewall-rules list :

gcloud compute firewall-rules list --filter network=NETWORK \
    --sort-by priority \
    --format="table(
        name,
        network,
        direction,
        priority,
        sourceRanges.list():label=SRC_RANGES,
        destinationRanges.list():label=DEST_RANGES,
        allowed[].map().firewall_rule().list():label=ALLOW,
        denied[].map().firewall_rule().list():label=DENY,
        sourceTags.list():label=SRC_TAGS,
        targetTags.list():label=TARGET_TAGS
        )"

Remplacez NETWORK par le nom du réseau dans lequel répertorier les règles de pare-feu.

API

Répertoriez toutes les règles de pare-feu VPC pour un réseau donné.

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls/?filter=network="NETWORK

Remplacez les éléments suivants :

PROJECT_ID : ID du projet où se trouve le réseau VPC.
NETWORK : nom du réseau VPC contenant les règles de pare-feu à répertorier.

Pour plus d'informations, reportez-vous à la méthode firewalls.list.

C#


using Google.Cloud.Compute.V1;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class ListFirewallRulesAsyncSample
{
    public async Task ListFirewallRulesAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id")
    {
        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        FirewallsClient client = await FirewallsClient.CreateAsync();

        // Make the request to list all firewall rules.
        await foreach (var firewallRule in client.ListAsync(projectId))
        {
            // The result is a Firewall sequence that you can iterate over.
            Console.WriteLine($"Firewal Rule: {firewallRule.Name}");
        }
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/api/iterator"
)

// listFirewallRules prints the list of firewall names and their descriptions in specified project
func listFirewallRules(w io.Writer, projectID string) error {
	// projectID := "your_project_id"

	ctx := context.Background()
	firewallsClient, err := compute.NewFirewallsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer firewallsClient.Close()

	req := &computepb.ListFirewallsRequest{
		Project: projectID,
	}

	it := firewallsClient.List(ctx, req)
	for {
		firewallRule, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s: %s\n", firewallRule.GetName(), firewallRule.GetDescription())
	}

	return nil
}

Java


import com.google.cloud.compute.v1.Firewall;
import com.google.cloud.compute.v1.FirewallsClient;
import com.google.cloud.compute.v1.FirewallsClient.ListPagedResponse;
import java.io.IOException;

public class ListFirewallRules {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample
    // project: project ID or project number of the Cloud project you want to use.
    String project = "your-project-id";
    listFirewallRules(project);
  }

  // Return a list of all the firewall rules in specified project.
  // Also prints the list of firewall names and their descriptions.
  public static ListPagedResponse listFirewallRules(String project)
      throws IOException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `firewallsClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (FirewallsClient firewallsClient = FirewallsClient.create()) {
      ListPagedResponse firewallResponse = firewallsClient.list(project);
      for (Firewall firewall : firewallResponse.iterateAll()) {
        System.out.println(firewall.getName());
      }
      return firewallResponse;
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';

const compute = require('@google-cloud/compute');

async function listFirewallRules() {
  const firewallsClient = new compute.FirewallsClient();

  const [firewallRules] = await firewallsClient.list({
    project: projectId,
  });

  for (const rule of firewallRules) {
    console.log(` - ${rule.name}: ${rule.description}`);
  }
}

listFirewallRules();

PHP

use Google\Cloud\Compute\V1\Client\FirewallsClient;
use Google\Cloud\Compute\V1\ListFirewallsRequest;

/**
 * Return a list of all the firewall rules in specified project. Also prints the
 * list of firewall names and their descriptions.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to list rules from.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 */
function list_firewall_rules(string $projectId)
{
    // List all firewall rules defined for the project using Firewalls Client.
    $firewallClient = new FirewallsClient();
    $request = (new ListFirewallsRequest())
        ->setProject($projectId);
    $firewallList = $firewallClient->list($request);

    print('--- Firewall Rules ---' . PHP_EOL);
    foreach ($firewallList->iterateAllElements() as $firewall) {
        printf(' -  %s : %s : %s' . PHP_EOL, $firewall->getName(), $firewall->getDescription(), $firewall->getNetwork());
    }
}

Python

from __future__ import annotations

from collections.abc import Iterable

from google.cloud import compute_v1


def list_firewall_rules(project_id: str) -> Iterable[compute_v1.Firewall]:
    """
    Return a list of all the firewall rules in specified project. Also prints the
    list of firewall names and their descriptions.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.

    Returns:
        A flat list of all firewall rules defined for given project.
    """
    firewall_client = compute_v1.FirewallsClient()
    firewalls_list = firewall_client.list(project=project_id)

    for firewall in firewalls_list:
        print(f" - {firewall.name}: {firewall.description}")

    return firewalls_list

Ruby


require "google/cloud/compute/v1"

# Return a list of all the firewall rules in specified project. Also prints the
# list of firewall names and their descriptions.
#
# @param [String] project project ID or project number of the project you want to use.
# @return [Array<::Google::Cloud::Compute::V1::Firewall>]
#     A list of all firewall rules defined for the given project.
def list_firewall_rules project:
  client = ::Google::Cloud::Compute::V1::Firewalls::Rest::Client.new
  firewalls = client.list project: project

  firewall_list = []
  firewalls.each do |firewall|
    puts " - #{firewall.name}: #{firewall.description}"
    firewall_list << firewall
  end

  firewall_list
end

Répertorier les règles de pare-feu VPC pour l'interface réseau d'une instance de VM

Pour chaque interface réseau, la console Google Cloud répertorie toutes les règles de pare-feu VPC qui s'appliquent à l'interface et les règles qui sont réellement utilisées par celle-ci. Les règles de pare-feu peuvent masquer d'autres règles. Il est donc possible que toutes les règles s'appliquant à une interface ne soient pas réellement utilisées par cette dernière.

Les règles de pare-feu sont associées et appliquées aux instances de VM via le paramètre cible d'une règle. En affichant toutes les règles appliquées, vous pouvez vérifier si une règle particulière est réellement appliquée à une interface.

Si vous activez la journalisation des règles de pare-feu, Firewall Insights peut fournir des insights sur vos règles de pare-feu afin de vous aider à mieux comprendre et optimiser en toute sécurité leurs configurations. Par exemple, vous pouvez afficher les règles d'une interface qui ont été appelées au cours des six dernières semaines. Pour en savoir plus, consultez la section sur l'utilisation de l'écran de détails de l'interface réseau de la VM dans la documentation Firewall Insights.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.list

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)
Administrateur de réseaux Compute (roles/compute.networkAdmin)
Lecteur de réseau Compute (roles/compute.networkViewer)
Lecteur de Compute (roles/compute.viewer)

Console

Pour afficher les règles VPC applicables à une interface réseau spécifique d'une instance de VM :

Dans Google Cloud Console, accédez à la page Instances de VM.

Accéder à la page "Instances de VM"
Recherchez l'instance à afficher.
Dans le menu Autres actions de l'instance (), sélectionnez Afficher les détails du réseau.
Si une instance comporte plusieurs interfaces réseau, sélectionnez celle à afficher dans le champ Interface réseau sélectionnée.
Dans la section Détails des pare-feu et des routes, sélectionnez l'onglet Pare-feu.
Développez vpc-firewall-rules.
Affichez la table pour déterminer si le trafic en provenance ou à destination d'une adresse IP spécifique est autorisé.

Afficher les détails d'une règle de pare-feu VPC

Vous pouvez inspecter une règle de pare-feu VPC pour voir son nom, son réseau et ses composants, et vérifier si la règle est activée ou désactivée.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.get

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)
Administrateur de réseaux Compute (roles/compute.networkAdmin)
Lecteur de réseau Compute (roles/compute.networkViewer)
Lecteur de Compute (roles/compute.viewer)

Console

Répertoriez vos règles de pare-feu. Vous pouvez afficher une liste de toutes les règles ou uniquement celles d'un réseau donné.
Cliquez sur la règle pour l'afficher.

gcloud

La commande suivante décrit une règle de pare-feu VPC individuelle. Les noms de règles de pare-feu étant uniques à chaque projet, vous n'avez pas besoin de spécifier un réseau pour décrire une règle existante.

gcloud compute firewall-rules describe RULE_NAME

Remplacez RULE_NAME par le nom de la règle de pare-feu.

API

Décrivez une règle de pare-feu VPC donnée.

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls/RULE_NAME

Remplacez les espaces réservés par des valeurs valides :

PROJECT_ID : ID du projet dans lequel se trouve la règle de pare-feu.
RULE_NAME : nom de la règle de pare-feu à décrire.

Pour plus d'informations, reportez-vous à la méthode firewalls.get.

Supprimer des règles de pare-feu VPC

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.delete

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

Console

Répertoriez vos règles de pare-feu VPC. Vous pouvez afficher une liste de toutes les règles ou uniquement celles d'un réseau donné.
Cliquez sur la règle à supprimer.
Cliquez sur Supprimer.
Cliquez à nouveau sur Supprimer pour confirmer votre choix.

gcloud

Pour supprimer une règle de pare-feu VPC, exécutez la commande gcloud compute firewall-rules delete :

gcloud compute firewall-rules delete RULE_NAME

Remplacez RULE_NAME par le nom de la règle à supprimer.

API

Supprimez une règle de pare-feu VPC.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls/RULE_NAME

Remplacez les éléments suivants :

PROJECT_ID : ID du projet dans lequel se trouve la règle de pare-feu.
RULE_NAME : nom de la règle de pare-feu à supprimer.

Pour plus d'informations, reportez-vous à la méthode firewalls.delete.

C#


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class DeleteFirewallRuleAsyncSample
{
    public async Task DeleteFirewallRuleAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string firewallRuleName = "my-test-firewall-rule")
    {

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        FirewallsClient client = await FirewallsClient.CreateAsync();

        // Make the request to delete the firewall rule.
        var firewallRuleDeletion = await client.DeleteAsync(projectId, firewallRuleName);

        // Wait for the operation to complete using client-side polling.
        await firewallRuleDeletion.PollUntilCompletedAsync();
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// deleteFirewallRule deletes a firewall rule from the project.
func deleteFirewallRule(w io.Writer, projectID, firewallRuleName string) error {
	// projectID := "your_project_id"
	// firewallRuleName := "europe-central2-b"

	ctx := context.Background()
	firewallsClient, err := compute.NewFirewallsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer firewallsClient.Close()

	req := &computepb.DeleteFirewallRequest{
		Project:  projectID,
		Firewall: firewallRuleName,
	}

	op, err := firewallsClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete firewall rule: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Firewall rule deleted\n")

	return nil
}

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.FirewallsClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DeleteFirewallRule {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample
    // project: project ID or project number of the Cloud project you want to use.
    // firewallRuleName: name of the firewall rule you want to delete.
    String project = "your-project-id";
    String firewallRuleName = "firewall-rule-name-" + UUID.randomUUID();
    deleteFirewallRule(project, firewallRuleName);
  }


  // Deletes a firewall rule from the project.
  public static void deleteFirewallRule(String project, String firewallRuleName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `firewallsClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (FirewallsClient firewallsClient = FirewallsClient.create()) {

      OperationFuture<Operation, Operation> operation = firewallsClient.deleteAsync(project,
          firewallRuleName);
      operation.get(3, TimeUnit.MINUTES);

      System.out.println("Deleted firewall rule -> " + firewallRuleName);
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const firewallRuleName = 'FIREWALL_RULE_NAME';

const compute = require('@google-cloud/compute');

async function deleteFirewallRule() {
  const firewallsClient = new compute.FirewallsClient();
  const operationsClient = new compute.GlobalOperationsClient();

  const [response] = await firewallsClient.delete({
    project: projectId,
    firewall: firewallRuleName,
  });
  let operation = response.latestResponse;

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
    });
  }

  console.log('Firewall rule deleted');
}

deleteFirewallRule();

PHP

use Google\Cloud\Compute\V1\Client\FirewallsClient;
use Google\Cloud\Compute\V1\DeleteFirewallRequest;

/**
 * Delete a firewall rule from the specified project.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to delete a rule for.
 * @param string $firewallRuleName Name of the rule that is deleted.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function delete_firewall_rule(string $projectId, string $firewallRuleName)
{
    $firewallsClient = new FirewallsClient();

    // Delete the firewall rule using Firewalls Client.
    $request = (new DeleteFirewallRequest())
        ->setFirewall($firewallRuleName)
        ->setProject($projectId);
    $operation = $firewallsClient->delete($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Rule %s deleted successfully!' . PHP_EOL, $firewallRuleName);
    } else {
        $error = $operation->getError();
        printf('Failed to delete firewall rule: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def delete_firewall_rule(project_id: str, firewall_rule_name: str) -> None:
    """
    Deletes a firewall rule from the project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        firewall_rule_name: name of the firewall rule you want to delete.
    """
    firewall_client = compute_v1.FirewallsClient()
    operation = firewall_client.delete(project=project_id, firewall=firewall_rule_name)

    wait_for_extended_operation(operation, "firewall rule deletion")

Ruby


require "google/cloud/compute/v1"

# Deletes a firewall rule from the project.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] name name of the firewall rule you want to delete.
def delete_firewall_rule project:, name:
  client = ::Google::Cloud::Compute::V1::Firewalls::Rest::Client.new
  operation = client.delete project: project, firewall: name

  wait_until_done operation: operation
end

Surveiller les règles de pare-feu VPC

Vous pouvez activer la journalisation des règles de pare-feu VPC pour voir quelle règle a autorisé ou bloqué quel trafic. Consultez la section Utiliser la journalisation des règles de pare-feu pour obtenir des instructions.

Configurer des règles de pare-feu VPC pour les cas d'utilisation courants

Les sections suivantes fournissent des exemples d'utilisation de gcloud CLI et de l'API pour recréer les règles de pare-feu VPC prédéfinies créées pour les réseaux par défaut. Vous pouvez utiliser les exemples ci-dessous pour créer des règles similaires pour vos réseaux en mode automatique et personnalisé. Chaque règle de pare-feu peut inclure des plages d'adresses IPv4 ou IPv6, mais pas les deux.

Autoriser les connexions d'entrée internes entre les VM

Les exemples suivants créent une règle de pare-feu pour autoriser les connexions internes TCP, UDP et ICMP à vos instances de VM, de la même manière que la règle allow-internal pour les réseaux par défaut.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

Exécutez la commande gcloud compute firewall-rules create :

gcloud compute firewall-rules create RULE_NAME \
    --action=ALLOW \
    --direction=INGRESS \
    --network=NETWORK \
    --priority=1000 \
    --rules=tcp:0-65535,udp:0-65535,ICMP_PROTOCOL \
    --source-ranges=SUBNET_RANGES

Remplacez les éléments suivants :

RULE_NAME : nom de cette règle de pare-feu.
NETWORK : nom du réseau auquel s'applique cette règle de pare-feu. La valeur par défaut est default.
ICMP_PROTOCOL : type de protocole ICMP. Spécifiez ICMPv4 à l'aide du nom de protocole icmp ou du numéro de protocole 1. Spécifiez ICMPv6 à l'aide du numéro de protocole 58.
SUBNET_RANGES : une ou plusieurs plages d'adresses IP. Si vous incluez une plage d'adresses IP, le trafic de cette plage peut atteindre n'importe quelle destination de VM dans le réseau VPC. Vous pouvez spécifier des plages IPv4 ou IPv6 dans une règle de pare-feu donnée.

Plages de sous-réseaux IPv4 :
- Les réseaux VPC en mode automatique utilisent des plages d'adresses IP situées dans 10.128.0.0/9.
- Les réseaux en mode personnalisé peuvent utiliser n'importe quelle plage IPv4 valide. Si vous n'utilisez pas de plages contiguës pour les sous-réseaux de votre réseau VPC, vous devrez peut-être spécifier plusieurs plages.
- Vous pouvez utiliser 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 pour autoriser le trafic provenant de toutes les plages d'adresses IPv4 privées (plages RFC 1918).
Plages de sous-réseaux IPv6 :
- Si vous avez attribué une plage d'adresses IPv6 interne à votre réseau VPC, vous pouvez l'utiliser comme plage source. Si vous utilisez la plage IPv6 interne du réseau VPC, la règle de pare-feu inclut toutes les plages de sous-réseaux IPv6 internes actuelles et futures. Vous pouvez trouver la plage IPv6 interne du réseau VPC à l'aide de la commande suivante :
```
gcloud compute networks describe NETWORK \
  --format="flattened(internalIpv6Range)"
```
  Vous pouvez également spécifier des plages de sous-réseaux IPv6 internes spécifiques.
- Pour autoriser le trafic provenant des plages de sous-réseaux IPv6 externes des sous-réseaux à double pile, vous devez spécifier la plage d'adresses IPv6 de chaque sous-réseau à inclure.

API

POST https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "kind": "compute#firewall",
  "name": "RULE_NAME",
  "network": "projects/PROJECT_ID/global/networks/NETWORK",
  "direction": "INGRESS",
  "priority": 1000,
  "targetTags": [],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "0-65535"
      ]
    },
    {
      "IPProtocol": "udp",
      "ports": [
        "0-65535"
      ]
    },
    {
      "IPProtocol": "ICMP_PROTOCOL"
    }
  ],
  "sourceRanges": [
    "SUBNET_RANGES"
  ]
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet où se trouve le réseau VPC.
RULE_NAME : nom de la règle de pare-feu.
NETWORK : nom du réseau VPC dans lequel la règle de pare-feu est créée. La valeur par défaut est default.
ICMP_PROTOCOL : type de protocole ICMP. Spécifiez ICMPv4 à l'aide du nom de protocole icmp ou du numéro de protocole 1. Spécifiez ICMPv6 à l'aide du numéro de protocole 58.
INTERNAL_SOURCE_RANGES : une ou plusieurs plages d'adresses IP. Pour autoriser le trafic interne dans tous les sous-réseaux de vos réseaux VPC, spécifiez les plages d'adresses IP utilisées dans votre réseau VPC. Vous pouvez spécifier des plages IPv4 ou IPv6 dans une règle de pare-feu donnée.

Plages de sous-réseaux IPv4 :
- Les réseaux VPC en mode automatique utilisent des plages d'adresses IP situées dans 10.128.0.0/9.
- Les réseaux en mode personnalisé peuvent utiliser n'importe quelle plage IPv4 valide. Si vous n'utilisez pas de plages contiguës pour les sous-réseaux de votre réseau VPC, vous devrez peut-être spécifier plusieurs plages.
- Vous pouvez utiliser 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 pour autoriser le trafic provenant de toutes les plages d'adresses IPv4 privées (plages RFC 1918).
Plages de sous-réseaux IPv6 :
- Si vous avez attribué une plage d'adresses IPv6 interne à votre réseau VPC, vous pouvez l'utiliser comme plage source. Si vous utilisez la plage IPv6 interne du réseau VPC, la règle de pare-feu inclut toutes les plages de sous-réseaux IPv6 internes actuelles et futures. Vous pouvez trouver la plage IPv6 interne du réseau VPC à l'aide de la commande suivante :
```
gcloud compute networks describe NETWORK \
  --format="flattened(internalIpv6Range)"
```
  Vous pouvez également spécifier des plages de sous-réseaux IPv6 internes spécifiques.
- Pour autoriser le trafic provenant des plages de sous-réseaux IPv6 externes des sous-réseaux à double pile, vous devez spécifier la plage d'adresses IPv6 de chaque sous-réseau à inclure.

Autoriser les connexions SSH d'entrée vers les VM

Les exemples suivants créent une règle de pare-feu pour autoriser les connexions SSH à vos instances de VM, de la même manière que la règle allow-ssh pour les réseaux par défaut.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

Exécutez la commande gcloud compute firewall-rules create :

gcloud compute firewall-rules create RULE_NAME \
    --action=ALLOW \
    --direction=INGRESS \
    --network=NETWORK \
    --priority=1000 \
    --rules=tcp:22 \
    --source-ranges=RANGES_OUTSIDE_VPC_NETWORK

Remplacez les éléments suivants :

RULE_NAME : nom de cette règle de pare-feu.
NETWORK : nom du réseau auquel s'applique cette règle de pare-feu. La valeur par défaut est default.
RANGES_OUTSIDE_VPC_NETWORK : une ou plusieurs plages d'adresses IP. Vous pouvez spécifier des plages IPv4 ou IPv6 dans une règle de pare-feu donnée. Il est recommandé de spécifier les plages d'adresses IP spécifiques à partir desquelles vous devez autoriser l'accès, plutôt que toutes les sources IPv4 ou IPv6.
- L'inclusion de 35.235.240.0/20 dans les plages sources permet les connexions SSH à l'aide du transfert TCP Identity-Aware Proxy (IAP) si toutes les autres conditions préalables sont remplies. Pour en savoir plus, consultez la page Utiliser IAP pour le transfert TCP.
- L'utilisation de 0.0.0.0/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv4, y compris de sources en dehors de Google Cloud.
- L'utilisation de ::/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv6, y compris de sources en dehors de Google Cloud.

API

POST https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "kind": "compute#firewall",
  "name": "RULE_NAME",
  "network": "projects/PROJECT_ID/global/networks/NETWORK",
  "direction": "INGRESS",
  "priority": 1000,
  "targetTags": [],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "22"
      ]
    }
  ],
  "sourceRanges": [
    "RANGES_OUTSIDE_VPC_NETWORK"
  ]
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet où se trouve le réseau VPC.
RULE_NAME : nom de la règle de pare-feu.
NETWORK : nom du réseau VPC dans lequel la règle de pare-feu est créée.
RANGES_OUTSIDE_VPC_NETWORK : une ou plusieurs plages d'adresses IP. Vous pouvez spécifier des plages IPv4 ou IPv6 dans une règle de pare-feu donnée. Il est recommandé de spécifier les plages d'adresses IP spécifiques à partir desquelles vous devez autoriser l'accès, plutôt que toutes les sources IPv4 ou IPv6.
- L'inclusion de 35.235.240.0/20 dans les plages sources permet les connexions SSH à l'aide du transfert TCP Identity-Aware Proxy (IAP) si toutes les autres conditions préalables sont remplies. Pour en savoir plus, consultez la page Utiliser IAP pour le transfert TCP.
- L'utilisation de 0.0.0.0/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv4, y compris de sources en dehors de Google Cloud.
- L'utilisation de ::/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv6, y compris de sources en dehors de Google Cloud.

Autoriser les connexions RDP d'entrée vers les VM

Les exemples suivants créent une règle de pare-feu autorisant les connexions RDP (Microsoft Remote Desktop Protocol) à vos instances de VM, de la même manière que la règle allow-rdp pour les réseaux par défaut.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

Exécutez la commande gcloud compute firewall-rules create :

gcloud compute firewall-rules create RULE_NAME \
    --action=ALLOW \
    --direction=INGRESS \
    --network=NETWORK \
    --priority=1000 \
    --rules=tcp:3389 \
    --source-ranges=RANGES_OUTSIDE_VPC_NETWORK

Remplacez les éléments suivants :

RULE_NAME : nom de cette règle de pare-feu.
NETWORK : nom du réseau auquel s'applique cette règle de pare-feu. La valeur par défaut est default.
RANGES_OUTSIDE_VPC_NETWORK : une ou plusieurs plages d'adresses IP. Vous pouvez spécifier des plages IPv4 ou IPv6 dans une règle de pare-feu donnée. Il est recommandé de spécifier les plages d'adresses IP spécifiques à partir desquelles vous devez autoriser l'accès, plutôt que toutes les sources IPv4 ou IPv6.
- L'inclusion de 35.235.240.0/20 dans les plages sources permet les connexions TRD à l'aide du transfert TCP Identity-Aware Proxy (IAP) si toutes les autres conditions préalables sont remplies. Pour en savoir plus, consultez la page Utiliser IAP pour le transfert TCP.
- L'utilisation de 0.0.0.0/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv4, y compris de sources en dehors de Google Cloud.
- L'utilisation de ::/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv6, y compris de sources en dehors de Google Cloud.

API

POST https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "kind": "compute#firewall",
  "name": "RULE_NAME",
  "network": "projects/PROJECT_ID/global/networks/NETWORK",
  "direction": "INGRESS",
  "priority": 1000,
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "3389"
      ]
    }
  ],
  "sourceRanges": [
    "EXTERNAL_SOURCE_RANGES"
  ]
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet où se trouve le réseau VPC.
RULE_NAME : nom de la règle de pare-feu.
NETWORK : nom du réseau VPC dans lequel la règle de pare-feu est créée.
RANGES_OUTSIDE_VPC_NETWORK : une ou plusieurs plages d'adresses IP. Vous pouvez spécifier des plages IPv4 ou IPv6 dans une règle de pare-feu donnée. Il est recommandé de spécifier les plages d'adresses IP spécifiques à partir desquelles vous devez autoriser l'accès, plutôt que toutes les sources IPv4 ou IPv6.
- L'inclusion de 35.235.240.0/20 dans les plages sources permet les connexions TRD à l'aide du transfert TCP Identity-Aware Proxy (IAP) si toutes les autres conditions préalables sont remplies. Pour en savoir plus, consultez la page Utiliser IAP pour le transfert TCP.
- L'utilisation de 0.0.0.0/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv4, y compris de sources en dehors de Google Cloud.
- L'utilisation de ::/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv6, y compris de sources en dehors de Google Cloud.

Autoriser les connexions ICMP d'entrée vers les VM

Les exemples suivants créent une règle de pare-feu pour autoriser les connexions ICMP à vos instances de VM, de la même manière que la règle allow-icmp pour les réseaux par défaut.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

Exécutez la commande gcloud compute firewall-rules create :

gcloud compute firewall-rules create RULE_NAME \
    --action=ALLOW \
    --direction=INGRESS \
    --network=NETWORK \
    --priority=1000 \
    --rules=ICMP_PROTOCOL \
    --source-ranges=RANGES_OUTSIDE_VPC_NETWORK

Remplacez les éléments suivants :

RULE_NAME : nom de la règle de pare-feu.
NETWORK : nom du réseau auquel s'applique cette règle de pare-feu. La valeur par défaut est default.
ICMP_PROTOCOL : type de protocole ICMP. Spécifiez ICMPv4 à l'aide du nom de protocole icmp ou du numéro de protocole 1. Spécifiez ICMPv6 à l'aide du numéro de protocole 58.
RANGES_OUTSIDE_VPC_NETWORK : une ou plusieurs plages d'adresses IP. Vous pouvez spécifier des plages IPv4 ou IPv6 dans une règle de pare-feu donnée. Il est recommandé de spécifier les plages d'adresses IP spécifiques à partir desquelles vous devez autoriser l'accès, plutôt que toutes les sources IPv4 ou IPv6.
- L'utilisation de 0.0.0.0/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv4, y compris de sources en dehors de Google Cloud.
- L'utilisation de ::/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv6, y compris de sources en dehors de Google Cloud.

API

POST https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "kind": "compute#firewall",
  "name": "RULE_NAME",
  "network": "projects/PROJECT_ID/global/networks/NETWORK",
  "direction": "INGRESS",
  "priority": 1000,
  "targetTags": [],
  "allowed": [
    {
      "IPProtocol": "ICMP_PROTOCOL"
    }
  ],
  "sourceRanges": [
    "RANGES_OUTSIDE_VPC_NETWORK"
  ]
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet où se trouve le réseau VPC.
RULE_NAME : nom de la règle de pare-feu.
NETWORK : nom du réseau VPC dans lequel la règle de pare-feu est créée.
ICMP_PROTOCOL : type de protocole ICMP à utiliser. Spécifiez ICMPv4 à l'aide du nom de protocole icmp ou du numéro de protocole 1. Spécifiez ICMPv6 à l'aide du numéro de protocole 58.
RANGES_OUTSIDE_VPC_NETWORK : une ou plusieurs plages d'adresses IP. Vous pouvez spécifier des plages IPv4 ou IPv6 dans une règle de pare-feu donnée. Il est recommandé de spécifier les plages d'adresses IP spécifiques à partir desquelles vous devez autoriser l'accès, plutôt que toutes les sources IPv4 ou IPv6.
- L'utilisation de 0.0.0.0/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv4, y compris de sources en dehors de Google Cloud.
- L'utilisation de ::/0 en tant que plage source autorise le trafic provenant de toutes les sources IPv6, y compris de sources en dehors de Google Cloud.

Autres exemples de configuration

La figure 1 décrit un exemple de configuration pour un réseau VPC nommé my-network. Le réseau contient les éléments suivants :

Un sous-réseau nommé subnet1 avec la plage d'adresses IP 10.240.10.0/24 et une seule instance
Un sous-réseau nommé subnet2 avec la plage d'adresses IP 192.168.1.0/24
Une instance nommée vm1 dans subnet2 avec le tag webserver et l'adresse IP interne 192.168.1.2
Une instance nommée vm2 dans subnet2 avec le tag database et l'adresse IP interne 192.168.1.3

Ce réseau VPC contient deux sous-réseaux qui contiennent chacun des VM : subnet2 contient des VM auxquelles des tags réseau sont attribués. — **Figure 1.** Ce réseau VPC contient deux sous-réseaux qui contiennent chacun des VM : subnet2 contient des VM auxquelles des tags réseau sont attribués (cliquez pour agrandir).

Exemple 1 : Refuser toutes les connexions TCP entrantes sauf celles à destination du port 80 depuis le sous-réseau subnet1

Cet exemple crée un ensemble de règles de pare-feu VPC qui refuse toutes les connexions TCP entrantes, à l'exception de celles destinées au port 80 depuis le sous-réseau subnet1.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

Créez une règle de pare-feu pour refuser tout le trafic TCP entrant sur les instances avec le tag webserver.

gcloud compute firewall-rules create deny-subnet1-webserver-access \
    --network NETWORK_NAME \
    --action deny \
    --direction ingress \
    --rules tcp \
    --source-ranges 0.0.0.0/0 \
    --priority 1000 \
    --target-tags webserver

Remplacez NETWORK_NAME par le nom du réseau.

Créez une règle de pare-feu pour autoriser toutes les adresses IP du sous-réseau subnet1 (10.240.10.0/24) à accéder au port TCP 80 sur les instances avec le tag webserver.

gcloud compute firewall-rules create vm1-allow-ingress-tcp-port80-from-subnet1 \
    --network NETWORK_NAME \
    --action allow \
    --direction ingress \
    --rules tcp:80 \
    --source-ranges 10.240.10.0/24 \
    --priority 50 \
    --target-tags webserver

Remplacez NETWORK_NAME par le nom du réseau.

Exemple 2 : Refuser toutes les connexions TCP sortantes sauf celles à destination du port 80 de vm1

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

Créez une règle de pare-feu pour refuser tout le trafic TCP sortant.

gcloud compute firewall-rules create deny-all-access \
    --network NETWORK_NAME \
    --action deny \
    --direction egress \
    --rules tcp \
    --destination-ranges 0.0.0.0/0 \
    --priority 1000

Remplacez NETWORK_NAME par le nom du réseau.

Créez une règle de pare-feu pour autoriser le trafic TCP destiné au port 80 de vm1.

gcloud compute firewall-rules create vm1-allow-egress-tcp-port80-to-vm1 \
    --network NETWORK_NAME \
    --action allow \
    --direction egress \
    --rules tcp:80 \
    --destination-ranges 192.168.1.2/32 \
    --priority 60

Remplacez NETWORK_NAME par le nom du réseau.

Exemple 3 : Autoriser les connexions TCP sortantes à destination du port 443 d'un hôte externe

Créez une règle de pare-feu permettant aux instances avec le tag webserver d'envoyer le trafic TCP sortant vers le port 443 d'une adresse IP externe (192.0.2.5).

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

gcloud compute firewall-rules create vm1-allow-egress-tcp-port443-to-192-0-2-5 \
    --network NETWORK_NAME \
    --action allow \
    --direction egress \
    --rules tcp:443 \
    --destination-ranges 192.0.2.5/32 \
    --priority 70 \
    --target-tags webserver

Remplacez NETWORK_NAME par le nom du réseau.

Exemple 4 : Autoriser les connexions SSH de vm2 à vm1

Créez une règle de pare-feu qui permet au trafic SSH provenant d'instances avec le tag database (vm2) d'atteindre des instances avec le tag webserver (vm1).

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

gcloud compute firewall-rules create vm1-allow-ingress-tcp-ssh-from-vm2 \
    --network NETWORK_NAME \
    --action allow \
    --direction ingress \
    --rules tcp:22 \
    --source-tags database \
    --priority 80 \
    --target-tags webserver

Remplacez NETWORK_NAME par le nom du réseau.

Exemple 5 : Autoriser le trafic TCP:1443 depuis le serveur Web vers la base de données à l'aide des comptes de service

Pour obtenir plus d'informations sur les comptes de service et les rôles, consultez la section Attribuer des rôles aux comptes de service.

Prenons l'exemple de la figure 2 dans laquelle deux applications sont mises à l'échelle automatiquement via des modèles : une application de serveur Web associée à un compte de service my-sa-webserver et une application de base de données associée au compte de service my-sa-database. Un administrateur de sécurité souhaite autoriser le trafic TCP provenant des VM disposant du compte de service my-sa-webserver vers le port de destination 1443 des VM disposant du compte de service my-sa-database.

Une règle de pare-feu autorise le trafic provenant d'une VM avec le compte de service my-sa-webserver vers le port 1443 d'une VM dont le compte de service est my-sa-database. — **Figure 2.** Une règle de pare-feu autorise le trafic provenant d'une VM avec le compte de service my-sa-webserver vers le port 1443 d'une VM dont le compte de service est my-sa-database (cliquez pour agrandir).

Voici les étapes de configuration (y compris la création des comptes de service) :

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.create

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)

gcloud

Un éditeur ou propriétaire de projet crée les comptes de service my-sa-webserver et my-sa-database.

gcloud iam service-accounts create my-sa-webserver \
    --display-name "webserver service account"

gcloud iam service-accounts create my-sa-database \
    --display-name "database service account"

Le propriétaire de projet attribue au développeur du serveur Web web-dev@example.com un rôle serviceAccountUser pour le compte de service my-sa-webserver en définissant un stratégie Identity and Access Management (IAM).
```
gcloud iam service-accounts add-iam-policy-binding \
my-sa-webserver@my-project.iam.gserviceaccount.com \
    --member='user:web-dev@example.com' \
    --role='roles/iam.serviceAccountUser'
```
Le propriétaire de projet attribue au développeur de base de données db-dev@example.com un rôle serviceAccountUser pour le compte de service my-sa-database en définissant une stratégie IAM.
```
gcloud iam service-accounts add-iam-policy-binding \
my-sa-database@my-project.iam.gserviceaccount.com \
    --member='user:db-dev@example.com' \
    --role='roles/iam.serviceAccountUser'
```
Le développeur web-dev@example.com, qui a le rôle d'administrateur d'instance, crée un modèle d'instance de serveur Web et autorise les instances à s'exécuter en tant que compte de service my-sa-webserver.
```
gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --service-account my-sa-webserver@my-project-123.iam.gserviceaccount.com
```
Le développeur db-dev@example.com, qui a le rôle d'administrateur d'instance, crée un modèle d'instance de base de données et autorise les instances à s'exécuter en tant que compte de service my-sa-database.
```
gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --service-account my-sa-database@my-project-123.iam.gserviceaccount.com
```

L'administrateur de sécurité crée une règle de pare-feu permettant au trafic TCP des VM avec le compte de service my-sa-webserver d'atteindre le port 1443 des VM dont le compte de service est my-sa-database.

gcloud compute firewall-rules create RULE_NAME \
    --network network_a \
    --allow TCP:1443 \
    --source-service-accounts my-sa-webserver@my-project.iam.gserviceaccount.com \
    --target-service-accounts my-sa-database@my-project.iam.gserviceaccount.com

Dépannage

Messages d'erreur lors de la création ou de la mise à jour d'une règle de pare-feu VPC

Un des messages d'erreur suivants peut s'afficher :

Should not specify destination range for ingress direction.

Les plages de destination ne sont pas des paramètres valides pour les règles de pare-feu d'entrée. Les règles de pare-feu sont supposées être des règles d'entrée, à moins qu'un sens de sortie (egress) ne soit spécifiquement défini. Si vous créez une règle qui ne spécifie pas de direction, elle est créée en tant que règle d'entrée, sans plage de destination. En outre, les plages de sources ne constituent pas des paramètres valides pour les règles de sortie.
Firewall direction cannot be changed once created.

Vous ne pouvez pas modifier la direction d'une règle de pare-feu existante. Vous devez créer une nouvelle règle avec les paramètres corrects, puis supprimer l'ancienne.
Firewall traffic control action cannot be changed once created.

Vous ne pouvez pas modifier l'action d'une règle de pare-feu existante. Vous devez créer une nouvelle règle avec les paramètres corrects, puis supprimer l'ancienne.

Service accounts must be valid RFC 822 email addresses. Le compte de service spécifié dans la règle de pare-feu doit être une adresse e-mail au format RFC 822.

gcloud compute firewall-rules create bad --allow tcp --source-service-accounts invalid-email

Creating firewall...failed.
ERROR: (gcloud.compute.firewall-rules.create) Could not fetch resource:
– Invalid value for field 'resource.sourceServiceAccounts[0]': 'invalid-email'. Service accounts must be valid RFC 822 email addresses.

ServiceAccounts and Tags are mutually exclusive and can't be combined in the same firewall rule. Vous ne pouvez pas spécifier à la fois des comptes de service et des tags dans la même règle.

gcloud compute firewall-rules create bad --allow tcp --source-service-accounts test@google.com --target-tags target

Creating firewall...failed.
 ERROR: (gcloud.compute.firewall-rules.create) Could not fetch resource:
– ServiceAccounts and Tags are mutually exclusive and can't be combined in the same firewall rule.

Erreur de ressource introuvable

Lorsque vous supprimez un réseau VPC ou une règle de pare-feu, un message semblable au suivant peut s'afficher : The resource "aet-uscentral1-subnet--1-egrfw" was not found.

Cette erreur peut vous empêcher de supprimer une règle de pare-feu implicite ou d'afficher ses détails. Une règle de pare-feu dans cet état peut également vous empêcher de supprimer un réseau VPC.

Pour supprimer une règle de pare-feu ou un réseau bloqué de cette manière, commencez par supprimer le connecteur d'accès au VPC sans serveur associé, puis réessayez. Pour en savoir plus sur la suppression d'un connecteur d'accès au VPC sans serveur, consultez la section Supprimer un connecteur.

Erreur en cas de pare-feu trop complexes

Le message d'erreur suivant peut s'afficher : Google Compute Engine: The network contains too many large firewalls.

Pour maintenir la sécurité et les performances, il existe une limite à la complexité et au nombre de règles de pare-feu pouvant être mises en œuvre dans un réseau VPC. Si cette erreur s'affiche, demandez à votre équipe chargée de la gestion de compte de simplifier ou de regrouper vos règles de pare-feu.

Impossibilité de se connecter à l'instance de VM

Si vous n'arrivez pas à vous connecter à une instance de VM, vérifiez vos règles de pare-feu.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes ou de l'un des rôles IAM suivants.

Autorisations

compute.firewalls.list

Rôles

Administrateur de sécurité de Compute (roles/compute.securityAdmin)
Administrateur de réseaux Compute (roles/compute.networkAdmin)
Lecteur de réseau Compute (roles/compute.networkViewer)
Lecteur de Compute (roles/compute.viewer)

gcloud

Si vous lancez la connexion à partir d'une autre instance de VM, répertoriez les règles de pare-feu de sortie pour cette instance.

gcloud compute firewall-rules list --filter network=NETWORK_NAME \
  --filter EGRESS \
  --sort-by priority \
  --format="table(
      name,
      network,
      direction,
      priority,
      sourceRanges.list():label=SRC_RANGES,
      destinationRanges.list():label=DEST_RANGES,
      allowed[].map().firewall_rule().list():label=ALLOW,
      denied[].map().firewall_rule().list():label=DENY,
      sourceTags.list():label=SRC_TAGS,
      sourceServiceAccounts.list():label=SRC_SVC_ACCT,
      targetTags.list():label=TARGET_TAGS,
      targetServiceAccounts.list():label=TARGET_SVC_ACCT
      )"

Remplacez NETWORK_NAME par le nom du réseau.

Vérifiez si l'adresse IP de destination est refusée par les règles de sortie. La règle avec la priorité la plus élevée (définie par la valeur la plus faible) remplace les règles avec les priorité moins élevées. Dans le cas de deux règles avec une priorité identique, la règle de refus est prioritaire.

Vérifiez la règle de pare-feu d'entrée pour le réseau qui contient l'instance de VM de destination.

gcloud compute firewall-rules list --filter network=NETWORK_NAME \
  --filter INGRESS \
  --sort-by priority \
  --format="table(
      name,
      network,
      direction,
      priority,
      sourceRanges.list():label=SRC_RANGES,
      destinationRanges.list():label=DEST_RANGES,
      allowed[].map().firewall_rule().list():label=ALLOW,
      denied[].map().firewall_rule().list():label=DENY,
      sourceTags.list():label=SRC_TAGS,
      sourceServiceAccounts.list():label=SRC_SVC_ACCT,
      targetTags.list():label=TARGET_TAGS,
      targetServiceAccounts.list():label=TARGET_SVC_ACCT
      )"

Remplacez NETWORK_NAME par le nom du réseau.

Exemple de résultat. Les résultats dépendent de votre liste de règles de pare-feu.

NAME                    NETWORK  DIRECTION  PRIORITY  SRC_RANGES    DEST_RANGES  ALLOW                         DENY  SRC_TAGS  SRC_SVC_ACCT      TARGET_TAGS  TARGET_SVC_ACCT
default-allow-icmp      default  INGRESS    65534     0.0.0.0/0                  icmp
default-allow-internal  default  INGRESS    65534     10.128.0.0/9               tcp:0-65535,udp:0-65535,icmp
default-allow-rdp       default  INGRESS    65534     0.0.0.0/0                  tcp:3389
default-allow-ssh       default  INGRESS    65534     0.0.0.0/0                  tcp:22
firewall-with-sa        default  INGRESS    1000                                 tcp:10000                                     test1@google.com               target@google.com

Vous pouvez également effectuer des tests de connectivité depuis/vers des instances de VM d'un réseau VPC vers un autre réseau VPC ou vers un réseau autre que Google Cloud pour déterminer si le trafic est interrompu par des règles de pare-feu d'entrée ou de sortie. Pour plus d'informations sur l'exécution de tests de connectivité pour résoudre différents problèmes, consultez la page Exécuter des tests de connectivité.

Ma règle de pare-feu VPC est-elle activée ou désactivée ?

Pour voir si une règle de pare-feu est activée ou désactivée, consultez les détails des règles de pare-feu.

Dans la console Google Cloud, recherchez Activé ou Désactivé dans la section Application forcée.

Dans la sortie de gcloud CLI, recherchez le champ disabled. Si disabled:false est affiché, la règle est activée et appliquée. Si disabled: true est affiché, la règle est désactivée.

Quelle règle est appliquée sur une instance de VM ?

Après avoir créé une règle, vous pouvez vérifier si elle est appliquée correctement sur une instance particulière. Pour plus d'informations, consultez la section Répertorier les règles de pare-feu pour l'interface réseau d'une instance de VM.

Les règles de pare-feu VPC contenant des tags sources ne prennent pas effet immédiatement

La propagation des règles de pare-feu d'entrée avec des tags sources peut prendre du temps. Pour en savoir plus, consultez les remarques liées aux tags sources pour les règles de pare-feu d'entrée.

Étapes suivantes

Pour une introduction aux règles de pare-feu, consultez la page Règles de pare-feu VPC.