VPC-Firewallregeln verwenden

Auf dieser Seite werden die Befehle für die Arbeit mit VPC-Firewallregeln (Virtual Private Cloud) und einige Beispiele für ihre Verwendung beschrieben. Mit VPC-Firewallregeln können Sie den Traffic zu oder von VM-Instanzen in einem VPC-Netzwerk (Virtual Private Cloud) anhand einer Portnummer, eines Tags oder eines Protokolls zulassen oder ablehnen.

Hinweis

Weitere Informationen zu VPC-Firewallregeln, wie z. B. implizierte Regeln und automatisch generierte Regeln für Standardnetzwerke, finden Sie unter VPC-Firewallregeln.

Sehen Sie sich vor dem Konfigurieren von Firewallregeln die Komponenten von Firewallregeln gründlich an, damit Sie sich mit den in Google Cloud verwendeten Firewallkomponenten vertraut machen.

VPC-Firewallregeln erstellen

VPC-Firewallregeln werden auf Netzwerkebene definiert und gelten nur für das Netzwerk, in dem sie erstellt werden. Der Name für jede Regel muss jedoch für das Projekt eindeutig sein.

Eine Firewallregel kann entweder IPv4- oder IPv6-Bereiche enthalten, aber nicht beides.

Wenn Sie eine Firewallregel erstellen, können Sie das Logging von Firewallregeln aktivieren. Wenn Sie das Logging aktivieren, können Sie Metadatenfelder ausschließen, um Speicherkosten zu sparen. Weitere Informationen finden Sie unter Logging von Firewallregeln verwenden.

Wenn Sie mehrere Dienstkonten für das Ziel- oder Quelldienstkontofeld angeben möchten, verwenden Sie die Google Cloud CLI, die API oder die Clientbibliotheken.

Das Standardnetzwerk bietet automatische Firewallregeln bei der Erstellung. Mit benutzerdefinierten und automatischen Netzwerken können Sie während der Netzwerkerstellung ähnliche Firewalls erstellen, wenn Sie die Google Cloud Console verwenden. Wenn Sie die gcloud CLI oder die API verwenden und ähnliche Firewallregeln erstellen möchten, die vom Standardnetzwerk bereitgestellt werden, finden Sie weitere Informationen unter Firewallregeln für gängige Anwendungsfälle konfigurieren.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

Console

Rufen Sie in der Google Cloud Console die Seite der Firewall-Richtlinien auf.

Zu den Firewall-Richtlinien
Klicken Sie auf Firewallregel erstellen.
Geben Sie einen Namen für die Firewallregel ein.

Dieser Name muss für das Projekt eindeutig sein.
(Optional) So aktivieren Sie das Logging von Firewallregeln:
- Klicken Sie auf Logs > Ein.
- Wenn Sie Metadaten weglassen möchten, maximieren Sie Logdetails ansehen und entfernen Sie dann das Häkchen aus dem Kästchen Metadaten einschließen.
Geben Sie das Netzwerk für die Firewallregel an.
Legen Sie die Priorität der Regel fest.

Je niedriger die Zahl, desto höher die Priorität.
Wählen Sie unter Traffic-Richtung die Option "Eingehend" oder "Ausgehend".
Wählen Sie unter Aktion bei Übereinstimmung die Option "Zulassen" oder "Ablehnen".
Geben Sie die Ziele der Regel an.
- Wenn diese Regel für alle Instanzen im Netzwerk gelten soll, wählen Sie All instances in the network aus.
- Wenn Sie die Regel auf bestimmte Instanzen nach Netzwerktag (Ziel) anwenden möchten, wählen Sie Angegebene Zieltags aus und geben Sie im Feld Zieltags die Tags ein, auf die Sie die Regel anwenden möchten.
- Wenn Sie die Regel auf bestimmte Instanzen nach verknüpftem Dienstkonto anwenden möchten, wählen Sie Angegebenes Dienstkonto aus und geben Sie unter Umfang des Dienstkontos an, ob sich das Dienstkonto im aktuellen oder in einem anderen Projekt befindet. Wählen Sie dann im Feld Zieldienstkonto den Namen des Dienstkontos aus oder geben Sie ihn ein.
Geben Sie für Eingangsregeln den Quellfilter an:
- Wenn Sie eingehenden Traffic nach IPv4-Quellbereichen filtern möchten, wählen Sie IPv4-Bereiche aus und geben Sie dann die CIDR-Blöcke in das Feld IPv4-Quellbereiche ein. Verwenden Sie 0.0.0.0/0 für jede IPv4-Quelle.
- Wenn Sie eingehenden Traffic nach IPv6-Quellbereichen filtern möchten, wählen Sie IPv6-Bereiche aus und geben Sie dann die CIDR-Blöcke in das Feld IPv6-Quellbereiche ein. Verwenden Sie ::/0 für jede IPv6-Quelle.
- Wenn Sie eingehenden Traffic nach Netzwerktag filtern möchten, wählen Sie Quelltags aus und geben Sie dann die Netzwerktags in das Feld Quelltags ein. Das Limit für die Anzahl der Quelltags finden Sie unter Limits pro Netzwerk. Das Filtern nach Quelltag ist nur verfügbar, wenn das Ziel nicht nach Dienstkonto angegeben ist. Weitere Informationen finden Sie unter Nach Dienstkonto oder Netzwerktag filtern.
- Wenn Sie eingehenden Traffic nach Dienstkonto filtern möchten, wählen Sie Dienstkonto aus und geben Sie unter Umfang des Dienstkontos an, ob sich das Dienstkonto im aktuellen oder in einem anderen Projekt befindet. Danach geben Sie das Dienstkonto im Feld Quelldienstkonto an. Das Filtern nach Quelldienstkonto ist nur verfügbar, wenn das Ziel nicht durch das Netzwerktag angegeben ist. Weitere Informationen finden Sie unter Nach Dienstkonto oder Netzwerktag filtern.
- Geben Sie ggf. einen zweiten Quellfilter an. Sekundäre Quellfilter können nicht die gleichen Filterkriterien wie primäre Quellfilter verwenden. Quell-IP-Bereiche können in Kombination mit Quelltags oder einem Quelldienstkonto verwendet werden. Das effektive Source-Set ist die Vereinigung der Quellbereichs-IP-Adressen und der durch Netzwerktags oder Dienstkonten identifizierten Instanzen. Das heißt, wenn entweder der Quell-IP-Bereich oder die Quelltags (oder Quelldienstkonten) den Filterkriterien entsprechen, wird die Quelle in das effektive Source-Set aufgenommen.
- Quelltags und Quelldienstkonto können nicht zusammen verwendet werden.
Geben Sie den Quellfilter für eine Regel für eingehenden Traffic an:
- Wenn Sie eingehenden Traffic nach IPv4-Zielbereichen filtern möchten, wählen Sie IPv4-Bereiche aus und geben Sie die CIDR-Blöcke in das Feld IPv4-Zielbereiche ein. Verwenden Sie 0.0.0.0/0 für jedes IPv4-Ziel.
- Wenn Sie eingehenden Traffic nach IPv6-Zielbereichen filtern möchten, wählen Sie IPv6-Bereiche aus und geben Sie die CIDR-Blöcke in das Feld IPv6-Zielbereiche ein. Verwenden Sie ::/0 für jedes IPv6-Ziel. Weitere Informationen finden Sie unter Ziel für Regeln für eingehenden Traffic.
Geben Sie für Ausgangsregeln den Zielfilter an:
- Wenn Sie ausgehenden Traffic nach IPv4-Zielbereichen filtern möchten, wählen Sie IPv4-Bereiche aus und geben Sie die CIDR-Blöcke in das Feld IPv4-Zielbereiche ein. Verwenden Sie 0.0.0.0/0 für jedes IPv4-Ziel.
- Wenn Sie ausgehenden Traffic nach IPv6-Zielbereichen filtern möchten, wählen Sie IPv6-Bereiche aus und geben Sie die CIDR-Blöcke in das Feld IPv6-Zielbereiche ein. Verwenden Sie ::/0 für jedes IPv6-Ziel.
Geben Sie den Zielfilter für eine Regel für ausgehenden Traffic an:
- Wenn Sie ausgehenden Traffic nach IPv4-Quellbereichen filtern möchten, wählen Sie IPv4-Bereiche aus und geben Sie die CIDR-Blöcke in das Feld IPv4-Quellbereiche ein. Verwenden Sie 0.0.0.0/0 für jede IPv4-Quelle.
- Wenn Sie ausgehenden Traffic nach IPv6-Quellbereichen filtern möchten, wählen Sie IPv6-Bereiche aus und geben Sie die CIDR-Blöcke in das Feld IPv6-Quellbereiche ein. Verwenden Sie ::/0 für jedes IPv6-Ziel. Weitere Informationen finden Sie unter Quelle für Regeln für ausgehenden Traffic.
Definieren Sie die Protokolle und Ports, auf die Sie die Regel anwenden möchten:
- Wenn die Regel auf alle Protokolle und Zielports angewendet werden soll, wählen Sie je nach Aktion Alle zulassen oder Alle ablehnen aus.
- Wählen Sie Angegebene Protokolle und Ports aus, um bestimmte Protokolle und Ports zu definieren:
  - Wählen Sie TCP aus, um das TCP-Protokoll und die entsprechenden Zielports einzuschließen. Geben Sie all oder eine durch Kommas getrennte Liste von Ziel-Ports ein, z. B. 20-22, 80, 8080.
  - Wählen Sie UDP aus, um das UDP-Protokoll und die entsprechenden Zielports einzuschließen. Geben Sie all oder eine durch Kommas getrennte Liste von Ziel-Ports ein, z. B. 67-69, 123.
  - Wählen Sie Sonstige aus, um Protokolle wie icmp, sctp oder eine Protokollnummer einzuschließen. Verwenden Sie beispielsweise icmp oder die Protokollnummer 1 für IPv4 ICMP. Verwenden Sie die Protokollnummer 58 für IPv6 ICMP.
    
    Weitere Informationen finden Sie unter Protokolle und Zielports.
(Optional) Wenn Sie den Erzwingungsstatus auf Deaktiviert setzen, wird die Firewallregel zwar erstellt, jedoch nicht erzwungen. Klicken Sie auf Regel deaktivieren und wählen Sie Deaktiviert aus.
Klicken Sie auf Erstellen.

gcloud

Verwenden Sie zum Erstellen einer VPC-Firewallregel den Befehl 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]

Verwenden Sie die unten aufgeführten Parameter. Weitere Informationen zu den einzelnen Parametern finden Sie unter SDK-Referenzdokumentation.

--network Das Netzwerk für die Regel. Bei Auslassung wird die Regel im Netzwerk default erstellt. Verwenden Sie dieses Feld, wenn Sie kein Standardnetzwerk haben oder die Regel in einem bestimmten Netzwerk erstellen möchten.
--priority Ein numerischer Wert, der die Priorität für die Regel angibt. Je niedriger die Zahl, desto höher die Priorität.
--direction Die Richtung des Traffics, entweder ingress oder egress.
--action Die Aktion bei Übereinstimmung, entweder allow oder deny. Muss mit dem Flag --rules verwendet werden.
Sie haben folgende Möglichkeiten, ein Ziel anzugeben:
- Lassen Sie --target-tags und --target-service-accounts aus, wenn die Regel auf alle Ziele im Netzwerk angewendet werden soll.
- Mit dem Flag --target-tags können Sie Ziele nach Netzwerk-Tags definieren.
- Mit dem Flag --target-service-accounts können Sie Ziele nach verknüpften Dienstkonten definieren.
Verwenden Sie für die Regel für eingehenden Traffic --destination-ranges, um IPv4- oder IPv6-Adressbereiche im CIDR-Format anzugeben. Wenn --destination-ranges weggelassen wird, ist das Ziel für eingehenden Traffic eine beliebige IPv4-Adresse, 0.0.0.0/0. Weitere Informationen finden Sie unter Ziele für Regeln für eingehenden Traffic und Ziel- und IP-Adressen für Regeln für eingehenden Traffic.
Geben Sie für Eingangsregeln eine Quelle an:
- --source-ranges Verwenden Sie dieses Flag, um Bereiche der IPv4- oder IPv6-Quelladressen im CIDR-Format anzugeben.
- Wenn --source-ranges, source-tags und --source-service-accounts weggelassen werden, ist die Quelle für eingehenden Traffic eine beliebige IPv4-Adresse, 0.0.0.0/0.
- --source-tags Verwenden Sie dieses Flag, um Quellinstanzen nach Netzwerktags anzugeben. Das Filtern nach Quelltag ist nur verfügbar, wenn das Ziel nicht nach Dienstkonto angegeben ist. Weitere Informationen finden Sie unter Nach Dienstkonto oder Netzwerktag filtern.
- --source-ranges und --source-tags können zusammen verwendet werden. Wenn beide angegeben sind, ist der effektive Quellsatz die Vereinigung der Quellbereich-IP-Adressen und der durch Netzwerktags identifizierten Instanzen, auch wenn die getaggten Instanzen keine IPs in den Quellbereichen haben.
- --source-service-accounts Verwenden Sie dieses Flag, um Quellinstanzen nach verwendetem Dienstkonto anzugeben. Das Filtern nach Quelldienstkonto ist nur verfügbar, wenn das Ziel nicht nach Netzwerktag angegeben ist. Weitere Informationen finden Sie unter Nach Dienstkonto oder Netzwerktag filtern. --source-ranges und --source-service-accounts können zusammen verwendet werden. Wenn beide angegeben sind, ist der effektive Quellsatz die Vereinigung der Quellbereich-IP-Adressen und der durch Quelldienstkonten identifizierten Instanzen, auch wenn die durch Quelldienstkonten identifizierten Instanzen keine IPs in den Quellbereichen haben.
Verwenden Sie Folgendes, um die Quelle zu optimieren: --source-ranges in
. Geben Sie IPv4- oder IPv6-Adressbereiche im CIDR-Format an. Wenn --source-ranges weggelassen wird, ist die Quelle für ausgehenden Traffic eine beliebige IPv4-Adresse, 0.0.0.0/0. Weitere Informationen finden Sie unter Quellen für Regeln für ausgehenden Traffic und Ziel- und IP-Adressen für Regeln für ausgehenden Traffic.
Geben Sie für Ausgangsregeln ein Ziel an:
- --destination-ranges Verwenden Sie dieses Flag, um Bereiche der IPv4- oder IPv6-Zieladressen im CIDR-Format anzugeben.
- Wenn --destination-ranges weggelassen wird, ist das Ziel für ausgehenden Traffic eine beliebige IPv4-Adresse, 0.0.0.0/0.
--rules Eine Liste der Protokolle und Zielports, auf die die Regel angewendet wird. Verwenden Sie all, um die Regel auf alle Protokolle und Ports anzuwenden. Erfordert das Flag --action.
Standardmäßig werden Firewallregeln automatisch erstellt und erzwungen. Sie können dieses Verhalten jedoch ändern.
- Bei Auslassung von sowohl --disabled als auch --no-disabled wird die Firewallregel erstellt und erzwungen.
- --disabled Fügen Sie dieses Flag hinzu, um die Firewallregel zu erstellen, jedoch nicht zu erzwingen. Die Firewallregel bleibt deaktiviert, bis Sie die Firewallregel aktualisieren, um sie zu aktivieren.
- --no-disabled Fügen Sie dieses Flag hinzu, damit die Firewallregel erzwungen wird.
--enable-logging | --no-enable-logging Sie können beim Erstellen oder Aktualisieren einer Regel das Logging von Firewallregeln aktivieren. Mit dem Logging von Firewallregeln können Sie die Auswirkungen Ihrer Firewallregeln überwachen, prüfen und analysieren. Weitere Informationen finden Sie unter Logging von Firewallregeln.
- --logging-metadata Wenn Sie das Logging aktivieren, sind in den Logs standardmäßig Basis- und Metadatenfelder enthalten. Sie können Metadatenfelder ausschließen, um Speicherkosten zu sparen. Weitere Informationen finden Sie unter Logging von Firewallregeln verwenden.

Terraform

Zum Erstellen einer Firewallregel können Sie eine google_compute_firewall-Ressource verwenden.

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

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

API

Erstellen Sie eine VPC-Firewallregel.

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

Ersetzen Sie Folgendes:

PROJECT_ID: die ID des Projekts, in dem sich das VPC-Netzwerk befindet.
NETWORK: der Name des VPC-Netzwerks, in dem die Firewallregel erstellt wird.
RULE_NAME: der Name der Firewallregel.
Geben Sie für eine Firewallregel für eingehenden Traffic die Quelle und das Ziel für eingehenden Traffic an:
- Verwenden Sie das Feld sourceRanges, sourceTags oder sourceServiceAccounts, um die Quelle für eingehenden Traffic anzugeben.
- sourceRanges können entweder IPv4- oder IPv6-Bereiche sein, aber keine Kombination aus beidem. Wenn Sie den Bereich 0.0.0.0/0 verwenden möchten, geben Sie kein Feld an.
- Sie können die Felder sourceTags und sourceServiceAccounts nicht zusammen verwenden. Sie können jedoch sourceRanges mit sourceTags oder sourceServiceAccounts verwenden. In diesem Fall muss die Verbindung nur mit einem der beiden übereinstimmen, damit die Firewallregel angewendet wird.
- Wenn Sie das Feld sourceTags für die Zielfelder verwenden, können Sie das Feld targetServiceAccounts nicht verwenden. Sie müssen das Feld targetTags oder kein Zielfeld verwenden. Wenn Sie das Feld sourceServiceAccounts verwenden, können Sie das Feld targetTags nicht verwenden. Wenn Sie kein Zielfeld angeben, gilt die Regel für alle Ziele im Netzwerk.
- Verwenden Sie das Feld destinationRanges, um das Ziel für eingehenden Traffic anzugeben. destinationRanges können entweder IPv4- oder IPv6-Bereiche sein, aber keine Kombination aus beidem.
  Wenn Sie kein Ziel angeben, verwendet Google Cloud 0.0.0.0/0. Weitere Informationen finden Sie unter Ziele für Regeln für eingehenden Traffic und Ziel- und IP-Adressen für Regeln für eingehenden Traffic.
Geben Sie für eine Firewallregel für ausgehenden Traffic die Quelle und das Ziel für ausgehenden Traffic an:
- Verwenden Sie das Feld sourceRanges, um die Quelle für ausgehenden Traffic anzugeben. sourceRange können entweder IPv4- oder IPv6-Bereiche sein, aber keine Kombination aus beidem.
  Wenn Sie kein Ziel angeben, verwendet Google Cloud 0.0.0.0/0. Weitere Informationen finden Sie unter Quellen für Regeln für ausgehenden Traffic und Ziel- und IP-Adressen für Regeln für ausgehenden Traffic.
- Verwenden Sie das Feld destinationRanges, um das Ziel anzugeben. destinationRanges können entweder IPv4- oder IPv6-Bereiche sein, aber keine Kombination aus beidem.
  Wenn Sie kein Ziel angeben, verwendet Google Cloud 0.0.0.0/0. Verwenden Sie das Feld targetTags oder targetServiceAccounts, um anzugeben, auf welche Ziele die Regel angewendet wird. Wenn Sie kein Zielfeld angeben, gilt die Regel für alle Ziele im Netzwerk.

Weitere Informationen und Beschreibungen für die einzelnen Felder finden Sie in der Methode 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

VPC-Firewallregeln aktualisieren

Sie können einige Komponenten einer VPC-Firewallregel ändern, z. B. die angegebenen Protokolle und Zielports für die Übereinstimmungsbedingung. Den Namen einer Firewallregel, das Netzwerk, die Aktion bei Übereinstimmung und die Richtung des Traffics können Sie nicht ändern.

Wenn Sie die Komponente „Name“, „Netzwerk“, „Aktion“ oder „Richtung“ ändern möchten, müssen Sie die Regel löschen und dann eine neue Regel erstellen.

Wenn Sie mehrere Dienstkonten hinzufügen oder entfernen möchten, verwenden Sie die gcloud CLI, die API oder die Clientbibliotheken. In der Google Cloud Console können Sie nicht mehrere Zieldienstkonten oder Quelldienstkonten angeben.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.update

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

Console

Rufen Sie in der Google Cloud Console die Seite der Firewall-Richtlinien auf.

Zu den Firewall-Richtlinien
Klicken Sie auf die Firewallregel, die Sie ändern möchten.
Klicken Sie auf Bearbeiten.
Sie können jede der bearbeitbaren Komponenten entsprechend Ihren Anforderungen ändern.
Klicken Sie auf Speichern.

gcloud

Verwenden Sie zum Aktualisieren von VPC-Firewallregeln den Befehl 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]

Die Beschreibungen der einzelnen Flags stimmen mit den Beschreibungen überein, die unter Firewallregeln erstellen aufgeführt sind. Weitere Informationen finden Sie in der SDK-Referenzdokumentation.

API

Verwenden Sie PATCH, um die folgenden Felder zu aktualisieren: allowed, description, sourceRanges, sourceTags oder targetTags. Verwenden Sie PUT oder POST für alle anderen Felder.

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

Ersetzen Sie Folgendes:

PROJECT_ID: die ID des Projekts, in dem sich das VPC-Netzwerk befindet.
NETWORK: der Name des VPC-Netzwerks, in dem sich die Firewallregel befindet.
RULE_NAME der Name der zu aktualisierenden Firewallregel.

Weitere Informationen und Beschreibungen für die einzelnen Felder finden Sie in der Methode firewalls.patch oder 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

VPC-Firewallregeln für ein VPC-Netzwerk auflisten

Sie können alle VPC-Firewallregeln für Ihr Projekt oder für ein bestimmtes VPC-Netzwerk auflisten. Für jede Firewallregel zeigt Google Cloud Details wie den Typ, die Ziele und die Filter der Regel an.

Wenn Sie das Logging von Firewallregeln aktivieren, erhalten Sie in Firewall Insights Informationen zu Ihren Firewallregeln, damit Sie deren Konfigurationen besser verstehen und sicher optimieren können. Sie können beispielsweise nachsehen, welche allow-Regeln in den letzten sechs Wochen nicht verwendet wurden. Weitere Informationen finden Sie in der Firewall Insights-Dokumentation unter Bildschirm mit Details zu Firewallregeln verwenden.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.list

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)
Compute-Netzwerkadministrator (roles/compute.networkAdmin)
Compute-Netzwerkbetrachter (roles/compute.networkViewer)
Compute-Betrachter (roles/compute.viewer)

Console

So rufen Sie alle VPC-Firewallregeln für alle Netzwerke in Ihrem Projekt auf:

Rufen Sie in der Google Cloud Console die Seite der Firewall-Richtlinien auf.

Zu den Firewall-Richtlinien

So rufen Sie VPC-Firewallregeln in einem bestimmten Netzwerk auf:

Rufen Sie in der Google Cloud Console die Seite VPC-Netzwerke auf.

Zur Seite VPC-Netzwerke
Klicken Sie auf den Namen eines VPC-Netzwerks, um zu dessen Detailseite zu wechseln.
Klicken Sie auf der Detailseite für das Netzwerk auf den Tab Firewalls.
Maximieren Sie vpc-firewall-rules.

gcloud

Verwenden Sie den Befehl gcloud compute firewall-rules list, um eine sortierte Liste von VPC-Firewallregeln für ein bestimmtes Netzwerk zu erstellen:

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

Ersetzen Sie NETWORK durch den Namen des Netzwerks, in dem Firewallregeln aufgelistet werden sollen.

API

Listen Sie alle VPC-Firewallregeln für ein bestimmtes Netzwerk auf.

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

Ersetzen Sie Folgendes:

PROJECT_ID: die ID des Projekts, in dem sich das VPC-Netzwerk befindet.
NETWORK: der Name des VPC-Netzwerks, das die aufzulistenden Firewallregeln enthält.

Weitere Informationen finden Sie in der Methode 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

VPC-Firewallregeln für die Netzwerkschnittstelle einer VM-Instanz auflisten

Für jede Netzwerkschnittstelle listet die Google Cloud Console alle für die Schnittstelle geltenden VPC-Firewallregeln und die Regeln auf, die tatsächlich von der Schnittstelle verwendet werden. Firewallregeln können andere Regeln maskieren. Daher werden möglicherweise nicht alle Regeln, die für eine Schnittstelle gelten, von der Schnittstelle tatsächlich verwendet.

Firewallregeln werden durch den Zielparameter einer Regel mit VM-Instanzen verknüpft und auf diese angewendet. Wenn Sie alle angewendeten Regeln aufrufen, können Sie überprüfen, ob eine bestimmte Regel auf eine Schnittstelle angewendet wird.

Wenn Sie das Logging von Firewallregeln aktivieren, erhalten Sie in Firewall Insights Informationen zu Ihren Firewallregeln, damit Sie deren Konfigurationen besser verstehen und sicher optimieren können. Sie können beispielsweise sehen, welche Regeln während der letzten sechs Wochen in einer Benutzeroberfläche angewendet wurden. Weitere Informationen finden Sie in der Firewall Insights-Dokumentation unter Bildschirm mit Details zur VM-Netzwerkschnittstelle verwenden.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.list

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)
Compute-Netzwerkadministrator (roles/compute.networkAdmin)
Compute-Netzwerkbetrachter (roles/compute.networkViewer)
Compute-Betrachter (roles/compute.viewer)

Console

So zeigen Sie die VPC-Regeln an, die für eine bestimmte Netzwerkschnittstelle einer VM-Instanz gelten:

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

Zu Seite „VM-Instanzen“
Suchen Sie die Instanz, die Sie ansehen möchten.
Wählen Sie im Dreipunkt-Menü () der Instanz die Option Netzwerkdetails anzeigen aus.
Wenn eine Instanz mehrere Netzwerkschnittstellen hat, wählen Sie im Feld Ausgewählte Netzwerkschnittstelle die Netzwerkschnittstelle aus, die Sie ansehen möchten.
Wählen Sie im Abschnitt Firewall- und Routendetails den Tab Firewalls aus.
Maximieren Sie vpc-firewall-rules.
Anhand der Tabelle können Sie feststellen, ob Traffic von oder zu einer bestimmten IP-Adresse zulässig ist.

Details zur VPC-Firewallregel ansehen

Sie können eine VPC-Firewallregel untersuchen, um deren Name, zutreffendes Netzwerk und Komponenten anzuzeigen und zu sehen, ob die Regel aktiviert oder deaktiviert ist.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.get

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)
Compute-Netzwerkadministrator (roles/compute.networkAdmin)
Compute-Netzwerkbetrachter (roles/compute.networkViewer)
Compute-Betrachter (roles/compute.viewer)

Console

Zeigen Sie die Firewallregeln in einer Liste an. Sie können die Liste nach einem bestimmten Netzwerk filtern oder alle Regeln aufrufen.
Klicken Sie auf die Regel, die Sie anzeigen möchten.

gcloud

Der folgende Befehl beschreibt eine einzelne VPC-Firewallregel. Da Namen für Firewallregeln nur für ein bestimmtes Projekt gelten, müssen Sie kein Netzwerk angeben, wenn Sie eine bestehende Firewallregel beschreiben.

gcloud compute firewall-rules describe RULE_NAME

Ersetzen Sie RULE_NAME durch den Namen der Firewallregel.

API

Beschreiben Sie eine bestimmte VPC-Firewallregel.

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

Ersetzen Sie die Platzhalter durch gültige Werte:

PROJECT_ID: die ID des Projekts, in dem sich die Firewallregel befindet.
RULE_NAME: der Name der zu beschreibenden Firewallregel.

Weitere Informationen finden Sie in der Methode firewalls.get.

VPC-Firewallregeln löschen

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.delete

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

Console

Listen Sie die VPC-Firewallregeln auf. Sie können die Liste nach einem bestimmten Netzwerk filtern oder alle Regeln aufrufen.
Klicken Sie auf die Regel, die Sie löschen möchten.
Klicken Sie auf Löschen.
Klicken Sie zur Bestätigung noch einmal auf Löschen.

gcloud

Verwenden Sie zum Löschen einer VPC-Firewallregel den Befehl gcloud compute firewall-rules delete:

gcloud compute firewall-rules delete RULE_NAME

Ersetzen Sie RULE_NAME durch den Namen der zu löschenden Regel.

API

Löschen Sie eine VPC-Firewallregel.

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

Ersetzen Sie Folgendes:

PROJECT_ID: die ID des Projekts, in dem sich die Firewallregel befindet.
RULE_NAME: der Name der zu löschenden Firewallregel.

Weitere Informationen finden Sie in der Methode 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

VPC-Firewallregeln überwachen

Wenn Sie das VPC-Firewallregel-Logging aktivieren, können Sie sehen, welche Regel welche Art von Traffic zulässt oder blockiert. Weitere Informationen finden Sie unter Firewallregel-Logging verwenden.

VPC-Firewallregeln für gängige Anwendungsfälle konfigurieren

In den folgenden Abschnitten finden Sie Beispiele dafür, wie Sie mit der gcloud CLI und der API die vordefinierten VPC-Firewallregeln für Standardnetzwerke neu erstellen. Sie können anhand der Beispiele ähnliche Regeln für Ihre Netzwerke im benutzerdefinierten und automatischen Modus erstellen. Jede Firewallregel kann entweder IPv4- oder IPv6-Adressbereiche enthalten, aber nicht beides.

Interne eingehende Verbindungen zwischen VMs zulassen

Die folgenden Beispiele erstellen eine Firewallregel, die interne TCP-, UDP- und ICMP-Verbindungen zu Ihren VM-Instanzen zulässt, ähnlich der Regel allow-internal für Standardnetzwerke.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

gcloud

Führen Sie den Befehl gcloud compute firewall-rules create aus:

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

Ersetzen Sie Folgendes:

RULE_NAME: der Name für diese Firewallregel.
NETWORK: der Name des Netzwerks, für das diese Firewallregel gilt. Der Standardwert ist default.
ICMP_PROTOCOL: der ICMP-Protokolltyp. Geben Sie ICMPv4 mit dem Protokollnamen icmp oder der Protokollnummer 1 an. Geben Sie die ICMPv6-Methode mit der Protokollnummer 58 an.
SUBNET_RANGES: ein oder mehrere IP-Adressbereiche. Wenn Sie einen IP-Adressbereich einbeziehen, kann der Traffic aus diesem Bereich jedes VM-Ziel im VPC-Netzwerk erreichen. Sie können in einer bestimmten Firewallregel entweder IPv4- oder IPv6-Bereiche angeben.

IPv4-Subnetzbereiche:
- VPC-Netzwerke im automatischen Modus verwenden IP-Adressbereiche innerhalb von 10.128.0.0/9.
- Netzwerke im benutzerdefinierten Modus können beliebige gültige IPv4-Bereiche verwenden. Wenn Sie keine zusammenhängenden Bereiche für die Subnetze in Ihrem VPC-Netzwerk verwenden, müssen Sie möglicherweise mehrere Bereiche angeben.
- Sie können 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 verwenden, um Traffic aus allen privaten IPv4-Adressbereichen (RFC 1918-Bereichen) zu erlauben.
IPv6-Subnetzbereiche:
- Wenn Sie Ihrem VPC-Netzwerk einen internen IPv6-Adressbereich zugewiesen haben, können Sie diesen Bereich als Quellbereich verwenden. Wenn Sie den internen IPv6-Bereich des VPC-Netzwerks verwenden, enthält die Firewallregel alle aktuellen und zukünftigen internen IPv6-Subnetzbereiche. Sie können den internen IPv6-Bereich des VPC-Netzwerks mit dem folgenden Befehl ermitteln:
```
gcloud compute networks describe NETWORK \
  --format="flattened(internalIpv6Range)"
```
  Sie können auch bestimmte interne IPv6-Subnetzbereiche angeben.
- Wenn Sie Traffic aus den externen IPv6-Subnetzbereichen von Dual-Stack-Subnetzen zulassen möchten, müssen Sie den IPv6-Adressbereich jedes gewünschten Subnetzes angeben, das Sie einbeziehen möchten.

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

Ersetzen Sie Folgendes:

PROJECT_ID: die ID des Projekts, in dem sich das VPC-Netzwerk befindet.
RULE_NAME: der Name der Firewallregel.
NETWORK: der Name des VPC-Netzwerks, in dem die Firewallregel erstellt wird. Der Standardwert ist default.
ICMP_PROTOCOL: der ICMP-Protokolltyp. Geben Sie ICMPv4 mit dem Protokollnamen icmp oder der Protokollnummer 1 an. Geben Sie die ICMPv6-Methode mit der Protokollnummer 58 an.
INTERNAL_SOURCE_RANGES: ein oder mehrere IP-Bereiche. Geben Sie die IP-Adressbereiche an, die in Ihrem VPC-Netzwerk verwendet werden, um internen Traffic innerhalb aller Subnetze in Ihren VPC-Netzwerken zuzulassen. Sie können in einer bestimmten Firewallregel entweder IPv4- oder IPv6-Bereiche angeben.

IPv4-Subnetzbereiche:
- VPC-Netzwerke im automatischen Modus verwenden IP-Adressbereiche innerhalb von 10.128.0.0/9.
- Netzwerke im benutzerdefinierten Modus können beliebige gültige IPv4-Bereiche verwenden. Wenn Sie keine zusammenhängenden Bereiche für die Subnetze in Ihrem VPC-Netzwerk verwenden, müssen Sie möglicherweise mehrere Bereiche angeben.
- Sie können 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 verwenden, um Traffic aus allen privaten IPv4-Adressbereichen (RFC 1918-Bereichen) zu erlauben.
IPv6-Subnetzbereiche:
- Wenn Sie Ihrem VPC-Netzwerk einen internen IPv6-Adressbereich zugewiesen haben, können Sie diesen Bereich als Quellbereich verwenden. Wenn Sie den internen IPv6-Bereich des VPC-Netzwerks verwenden, enthält die Firewallregel alle aktuellen und zukünftigen internen IPv6-Subnetzbereiche. Sie können den internen IPv6-Bereich des VPC-Netzwerks mit dem folgenden Befehl ermitteln:
```
gcloud compute networks describe NETWORK \
  --format="flattened(internalIpv6Range)"
```
  Sie können auch bestimmte interne IPv6-Subnetzbereiche angeben.
- Wenn Sie Traffic aus den externen IPv6-Subnetzbereichen von Dual-Stack-Subnetzen zulassen möchten, müssen Sie den IPv6-Adressbereich jedes gewünschten Subnetzes angeben, das Sie einbeziehen möchten.

Eingehende SSH-Verbindungen zu VMs zulassen

Die folgenden Beispiele erstellen eine Firewallregel, die SSH-Verbindungen zu Ihren VM-Instanzen zulässt, ähnlich der Regel allow-ssh für Standardnetzwerke.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

gcloud

Führen Sie den Befehl gcloud compute firewall-rules create aus:

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

Ersetzen Sie Folgendes:

RULE_NAME: der Name für diese Firewallregel.
NETWORK: der Name des Netzwerks, für das diese Firewallregel gilt. Der Standardwert ist default.
RANGES_OUTSIDE_VPC_NETWORK: ein oder mehrere IP-Adressbereiche. Sie können in einer bestimmten Firewallregel entweder IPv4- oder IPv6-Bereiche angeben. Als Best Practice sollten Sie statt aller IPv4- oder IPv6-Quellen die spezifischen IP-Adressbereiche angeben, von denen aus Sie Zugriff gewähren möchten.
- Wenn Sie 35.235.240.0/20 in die Quellbereiche aufnehmen, sind SSH-Verbindungen mit der TCP-Weiterleitung von Identity-Aware Proxy (IAP) möglich, wenn alle anderen Voraussetzungen erfüllt sind. Weitere Informationen finden Sie unter IAP für TCP-Weiterleitung verwenden.
- Wenn Sie 0.0.0.0/0 als Quellbereich verwenden, wird Traffic von allen IPv4-Quellen zugelassen, einschließlich Quellen außerhalb von Google Cloud.
- Wenn Sie ::/0 als Quellbereich verwenden, können Sie Traffic von allen IPv6-Quellen zulassen, einschließlich von Quellen außerhalb von 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"
  ]
}

Ersetzen Sie Folgendes:

PROJECT_ID: die ID des Projekts, in dem sich das VPC-Netzwerk befindet.
RULE_NAME: der Name der Firewallregel.
NETWORK: der Name des VPC-Netzwerks, in dem die Firewallregel erstellt wird.
RANGES_OUTSIDE_VPC_NETWORK: ein oder mehrere IP-Adressbereiche. Sie können in einer bestimmten Firewallregel entweder IPv4- oder IPv6-Bereiche angeben. Als Best Practice sollten Sie statt aller IPv4- oder IPv6-Quellen die spezifischen IP-Adressbereiche angeben, von denen aus Sie Zugriff gewähren möchten.
- Wenn Sie 35.235.240.0/20 in die Quellbereiche aufnehmen, sind SSH-Verbindungen mit der TCP-Weiterleitung von Identity-Aware Proxy (IAP) möglich, wenn alle anderen Voraussetzungen erfüllt sind. Weitere Informationen finden Sie unter IAP für TCP-Weiterleitung verwenden.
- Wenn Sie 0.0.0.0/0 als Quellbereich verwenden, wird Traffic von allen IPv4-Quellen zugelassen, einschließlich Quellen außerhalb von Google Cloud.
- Wenn Sie ::/0 als Quellbereich verwenden, können Sie Traffic von allen IPv6-Quellen zulassen, einschließlich von Quellen außerhalb von Google Cloud.

Eingehende RDP-Verbindungen zu VMs zulassen

Die folgenden Beispiele erstellen eine Firewallregel, die RDP-Verbindungen von Microsoft (Remote Desktop Protocol) zu Ihren VM-Instanzen zulässt, ähnlich der Regel allow-rdp für Standardnetzwerke.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

gcloud

Führen Sie den Befehl gcloud compute firewall-rules create aus:

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

Ersetzen Sie Folgendes:

RULE_NAME: der Name für diese Firewallregel.
NETWORK: der Name des Netzwerks, für das diese Firewallregel gilt. Der Standardwert ist default.
RANGES_OUTSIDE_VPC_NETWORK: ein oder mehrere IP-Adressbereiche. Sie können in einer bestimmten Firewallregel entweder IPv4- oder IPv6-Bereiche angeben. Als Best Practice sollten Sie statt aller IPv4- oder IPv6-Quellen die spezifischen IP-Adressbereiche angeben, von denen aus Sie Zugriff gewähren möchten.
- Wenn Sie 35.235.240.0/20 in die Quellbereiche aufnehmen, sind RDP-Verbindungen mit der TCP-Weiterleitung von Identity-Aware Proxy (IAP) möglich, wenn alle anderen Voraussetzungen erfüllt sind. Weitere Informationen finden Sie unter IAP für TCP-Weiterleitung verwenden.
- Wenn Sie 0.0.0.0/0 als Quellbereich verwenden, wird Traffic von allen IPv4-Quellen zugelassen, einschließlich Quellen außerhalb von Google Cloud.
- Wenn Sie ::/0 als Quellbereich verwenden, können Sie Traffic von allen IPv6-Quellen zulassen, einschließlich von Quellen außerhalb von 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"
  ]
}

Ersetzen Sie Folgendes:

PROJECT_ID: die ID des Projekts, in dem sich das VPC-Netzwerk befindet.
RULE_NAME: der Name der Firewallregel.
NETWORK: der Name des VPC-Netzwerks, in dem die Firewallregel erstellt wird.
RANGES_OUTSIDE_VPC_NETWORK: ein oder mehrere IP-Adressbereiche. Sie können in einer bestimmten Firewallregel entweder IPv4- oder IPv6-Bereiche angeben. Als Best Practice sollten Sie statt aller IPv4- oder IPv6-Quellen die spezifischen IP-Adressbereiche angeben, von denen aus Sie Zugriff gewähren möchten.
- Wenn Sie 35.235.240.0/20 in die Quellbereiche aufnehmen, sind RDP-Verbindungen mit der TCP-Weiterleitung von Identity-Aware Proxy (IAP) möglich, wenn alle anderen Voraussetzungen erfüllt sind. Weitere Informationen finden Sie unter IAP für TCP-Weiterleitung verwenden.
- Wenn Sie 0.0.0.0/0 als Quellbereich verwenden, wird Traffic von allen IPv4-Quellen zugelassen, einschließlich Quellen außerhalb von Google Cloud.
- Wenn Sie ::/0 als Quellbereich verwenden, können Sie Traffic von allen IPv6-Quellen zulassen, einschließlich von Quellen außerhalb von Google Cloud.

Eingehende ICMP-Verbindungen zu VMs zulassen

Die folgenden Beispiele erstellen eine Firewallregel, die ICMP-Verbindungen zu Ihren VM-Instanzen zulässt, ähnlich der Regel allow-icmp für Standardnetzwerke.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

gcloud

Führen Sie den Befehl gcloud compute firewall-rules create aus:

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

Ersetzen Sie Folgendes:

RULE_NAME: der Name der Firewallregel.
NETWORK: der Name des Netzwerks, für das diese Firewallregel gilt. Der Standardwert ist default.
ICMP_PROTOCOL: der ICMP-Protokolltyp. Geben Sie ICMPv4 mit dem Protokollnamen icmp oder der Protokollnummer 1 an. Geben Sie die ICMPv6-Methode mit der Protokollnummer 58 an.
RANGES_OUTSIDE_VPC_NETWORK: ein oder mehrere IP-Adressbereiche. Sie können in einer bestimmten Firewallregel entweder IPv4- oder IPv6-Bereiche angeben. Als Best Practice sollten Sie statt aller IPv4- oder IPv6-Quellen die spezifischen IP-Adressbereiche angeben, von denen aus Sie Zugriff gewähren möchten.
- Wenn Sie 0.0.0.0/0 als Quellbereich verwenden, wird Traffic von allen IPv4-Quellen zugelassen, einschließlich Quellen außerhalb von Google Cloud.
- Wenn Sie ::/0 als Quellbereich verwenden, können Sie Traffic von allen IPv6-Quellen zulassen, einschließlich von Quellen außerhalb von 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"
  ]
}

Ersetzen Sie Folgendes:

PROJECT_ID: die ID des Projekts, in dem sich das VPC-Netzwerk befindet.
RULE_NAME: der Name der Firewallregel.
NETWORK: der Name des VPC-Netzwerks, in dem die Firewallregel erstellt wird.
ICMP_PROTOCOL: der Typ des ICMP-Protokolls, das verwendet werden soll. Geben Sie ICMPv4 mit dem Protokollnamen icmp oder der Protokollnummer 1 an. Geben Sie die ICMPv6-Methode mit der Protokollnummer 58 an.
RANGES_OUTSIDE_VPC_NETWORK: ein oder mehrere IP-Adressbereiche. Sie können in einer bestimmten Firewallregel entweder IPv4- oder IPv6-Bereiche angeben. Als Best Practice sollten Sie statt aller IPv4- oder IPv6-Quellen die spezifischen IP-Adressbereiche angeben, von denen aus Sie Zugriff gewähren möchten.
- Wenn Sie 0.0.0.0/0 als Quellbereich verwenden, wird Traffic von allen IPv4-Quellen zugelassen, einschließlich Quellen außerhalb von Google Cloud.
- Wenn Sie ::/0 als Quellbereich verwenden, können Sie Traffic von allen IPv6-Quellen zulassen, einschließlich von Quellen außerhalb von Google Cloud.

Weitere Konfigurationsbeispiele

Abbildung 1 beschreibt eine Beispielkonfiguration für ein VPC-Netzwerk mit dem Namen my-network. Das Netzwerk enthält Folgendes:

Ein Subnetz mit dem Namen subnet1 und dem IP-Bereich 10.240.10.0/24 und einer einzelnen Instanz
Ein Subnetz mit dem Namen subnet2 und dem IP-Bereich 192.168.1.0/24
Eine Instanz mit dem Namen vm1 in subnet2 mit dem Tag webserver und der internen IP-Adresse 192.168.1.2
Eine Instanz mit dem Namen vm2 in subnet2 mit dem Tag database und der internen IP-Adresse 192.168.1.3

Dieses VPC-Netzwerk enthält zwei Subnetze, die jeweils VMs enthalten; subnet2 enthält VMS, denen Netzwerk-Tags zugewiesen sind. — **Abbildung 1.** Dieses VPC-Netzwerk enthält zwei Subnetze, die jeweils VMs enthalten; subnet2 enthält VMS, denen Netzwerk-Tags zugewiesen sind (zum Vergrößern klicken).

Beispiel 1: Alle eingehenden TCP-Verbindungen mit Ausnahme von Port 80 aus subnet1 ablehnen

In diesem Beispiel werden mehrere VPC-Firewallregeln erstellt, die alle eingehenden TCP-Verbindungen außer denen mit dem Zielport 80 von subnet1 blockieren.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

gcloud

Erstellen Sie eine Firewallregel, die den gesamten eingehenden TCP-Traffic zu Instanzen mit dem Tag webserver ablehnt.

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

Ersetzen Sie NETWORK_NAME durch den Namen des Netzwerks.

Erstellen Sie eine Firewallregel, die allen IP-Adressen in subnet1 (10.240.10.0/24) den Zugriff auf TCP-Port 80 auf Instanzen mit dem Tag webserver gewährt.

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

Ersetzen Sie NETWORK_NAME durch den Namen des Netzwerks.

Beispiel 2: Alle ausgehenden TCP-Verbindungen mit Ausnahme von Port 80 von vm1 ablehnen

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

gcloud

Erstellen Sie eine Firewallregel, die den gesamten ausgehenden TCP-Traffic ablehnt.

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

Ersetzen Sie NETWORK_NAME durch den Namen des Netzwerks.

Erstellen Sie eine Firewallregel, die den TCP-Traffic an vm1 mit dem Port 80 zulässt.

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

Ersetzen Sie NETWORK_NAME durch den Namen des Netzwerks.

Beispiel 3: Ausgehende TCP-Verbindungen an Port 443 eines externen Hosts zulassen

Erstellen Sie eine Firewallregel, die für Instanzen mit dem Tag webserver ausgehenden TCP-Traffic an Port 443 für die externe Beispiel-IP-Adresse 192.0.2.5 zulässt.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (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

Ersetzen Sie NETWORK_NAME durch den Namen des Netzwerks.

Beispiel 4: SSH-Verbindungen von vm2 zu vm1 zulassen

Erstellen Sie eine Firewallregel, die SSH-Traffic von Instanzen mit dem Tag database (vm2) zu Instanzen mit dem Tag webserver (vm1) zulässt.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (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

Ersetzen Sie NETWORK_NAME durch den Namen des Netzwerks.

Beispiel 5: TCP:1443 vom Webserver zur Datenbank über Dienstkonten zulassen

Weitere Informationen zu Dienstkonten und Rollen finden Sie unter Rollen für Dienstkonten zuweisen.

Betrachten Sie das Szenario in Abbildung 2, in dem zwei Anwendungen automatisch über Vorlagen skaliert werden: eine Webserveranwendung, die mit einem my-sa-webserver-Dienstkonto verknüpft ist, und eine Datenbankanwendung, die mit einem my-sa-database-Dienstkonto verknüpft ist. Ein Sicherheitsadministrator möchte TCP-Traffic von VMs mit dem Dienstkonto my-sa-webserver zum Zielport 1443 von VMs mit dem Dienstkonto my-sa-database zulassen.

Eine Firewallregel lässt Traffic von einer VM mit dem Dienstkonto „my-sa-webserver“ zu Port 1443 einer VM mit dem Dienstkonto „my-sa-database“ zu. — **Abbildung 2.** Eine Firewallregel lässt Traffic von einer VM mit dem Dienstkonto „my-sa-webserver“ zu Port 1443 einer VM mit dem Dienstkonto „my-sa-database“ zu (zum Vergrößern klicken).

Weiter unten finden Sie die Konfigurationsschritte, einschließlich derer für das Erstellen der Dienstkonten.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.create

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)

gcloud

Ein Projektbearbeiter oder Projektinhaber erstellt die Dienstkonten my-sa-webserver und 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"

Ein Projektinhaber weist dem Webserverentwickler web-dev@example.com die Rolle serviceAccountUser für das Dienstkonto my-sa-webserver zu. Dazu wird eine IAM-Richtlinie (Identity and Access Management) festgelegt.
```
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'
```

Ein Projektinhaber weist dem Datenbankentwickler db-dev@example.com die Rolle serviceAccountUser für das Dienstkonto my-sa-database zu und richtet dafür eine IAM-Richtlinie ein.

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'

Der Entwickler web-dev@example.com, der die Rolle "Instanzadministrator" hat, erstellt die Vorlage für Webserverinstanzen und autorisiert die Ausführung von Instanzen über das Dienstkonto my-sa-webserver.
```
gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --service-account my-sa-webserver@my-project-123.iam.gserviceaccount.com
```
Der Entwickler db-dev@example.com, der die Rolle "Instanzadministrator" hat, erstellt die Vorlage für Datenbankinstanzen und autorisiert die Ausführung von Instanzen über das Dienstkonto my-sa-database.
```
gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --service-account my-sa-database@my-project-123.iam.gserviceaccount.com
```

Der Sicherheitsadministrator erstellt eine Firewallregel, die TCP-Traffic von VMs mit dem Dienstkonto my-sa-webserver zulässt, um Port 1443 von VMs mit dem Dienstkonto my-sa-database zu erreichen.

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

Fehlerbehebung

Fehlermeldungen beim Erstellen oder Aktualisieren einer VPC-Firewallregel

Möglicherweise wird eine der folgenden Fehlermeldungen angezeigt:

Should not specify destination range for ingress direction.

Zielbereiche sind keine gültigen Parameter für Firewallregeln für den eingehenden Traffic. Es wird davon ausgegangen, dass die Firewallregeln den eingehenden Traffic betreffen, es sei denn, egress wäre als spezifische Richtung angegeben. Wenn Sie eine Regel erstellen, die keine Richtung angibt, wird sie als Regel für eingehenden Traffic erstellt. Dann sind Zielbereiche nicht zulässig. Gleichermaßen sind Quellbereiche keine gültigen Parameter für Ausgangsregeln.
Firewall direction cannot be changed once created.

Sie können die Richtung einer vorhandenen Firewallregel nicht ändern. Sie müssen eine neue Regel mit den korrekten Parametern erstellen und dann die alte Regel löschen.
Firewall traffic control action cannot be changed once created.

Sie können die Aktion einer bestehenden Firewallregel nicht ändern. Sie müssen eine neue Regel mit den korrekten Parametern erstellen und dann die alte Regel löschen.

Service accounts must be valid RFC 822 email addresses. Das in der Firewallregel angegebene Dienstkonto muss eine gemäß RFC 822 formatierte E-Mail-Adresse sein.

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. Sie können nicht sowohl Dienstkonten als auch Tags in derselben Regel angeben.

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.

Fehler bezüglich nicht gefundener Ressource

Wenn Sie ein VPC-Netzwerk oder eine Firewallregel löschen, wird möglicherweise eine Meldung wie diese angezeigt: The resource "aet-uscentral1-subnet--1-egrfw" was not found.

Durch diesen Fehler wird möglicherweise verhindert, dass Sie eine implizierte Firewallregel löschen oder ihre Details aufrufen können. Außerdem verhindert eine Firewallregel mit diesem Status möglicherweise, dass ein VPC-Netzwerk gelöscht werden kann.

Wenn Sie eine Firewallregel oder ein Netzwerk löschen möchten, das auf diese Weise blockiert ist, löschen Sie zuerst den zugehörigen Connector für serverlosen VPC-Zugriff und versuchen Sie es dann noch einmal. Weitere Informationen zum Löschen eines Connectors für serverlosen VPC-Zugriff finden Sie unter Connector löschen.

Fehler bei zu vielen großen Firewalls

Möglicherweise wird die folgende Fehlermeldung angezeigt: Google Compute Engine: The network contains too many large firewalls.

Für eine angemessene Sicherheit und Leistung ist die Komplexität und Anzahl der Firewallregeln, die in einem VPC-Netzwerk implementiert werden können, begrenzt. Wenn dieser Fehler angezeigt wird, bitten Sie Ihr Account-Management-Team, Ihre Firewallregeln zu vereinfachen oder zu konsolidieren.

Keine Verbindung zur VM-Instanz möglich

Wenn Sie keine Verbindung zu einer VM-Instanz herstellen können, überprüfen Sie Ihre Firewallregeln.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen oder eine der folgenden IAM-Rollen.

Berechtigungen

compute.firewalls.list

Rollen

Compute-Sicherheitsadministrator (roles/compute.securityAdmin)
Compute-Netzwerkadministrator (roles/compute.networkAdmin)
Compute-Netzwerkbetrachter (roles/compute.networkViewer)
Compute-Betrachter (roles/compute.viewer)

gcloud

Wenn Sie die Verbindung von einer anderen VM-Instanz aus initiieren, listen Sie die ausgehenden Firewallregeln für diese Instanz auf.

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

Ersetzen Sie NETWORK_NAME durch den Namen des Netzwerks.

Überprüfen Sie, ob die Ziel-IP von ausgehenden Regeln blockiert wird. Die Regel mit der höchsten Priorität (niedrigste Prioritätsnummer) überschreibt Regeln mit niedrigerer Priorität. Bei Regeln mit derselben Priorität hat die "deny"-Regel Vorrang.

Prüfen Sie die eingehende Firewallregel für das Netzwerk, das die Ziel-VM-Instanz enthält.

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

Ersetzen Sie NETWORK_NAME durch den Namen des Netzwerks.

Beispielausgabe. Die Ausgabe hängt von Ihrer Liste der Firewallregeln ab.

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

Sie können auch Verbindungstests zu oder von VM-Instanzen in einem VPC-Netzwerk mit einem anderen VPC-Netzwerk oder Nicht-Google Cloud-Netzwerk durchführen, um festzustellen, ob der Traffic durch Firewallregeln für eingehenden oder ausgehenden Traffic verloren geht. Weitere Informationen zur Fehlerbehebung in verschiedenen Szenarien mithilfe von Konnektivitätstests finden Sie unter Konnektivitätstests ausführen.

Ist meine VPC-Firewallregel aktiviert oder deaktiviert?

Unter Details zu Firewallregeln können Sie sehen, ob eine Firewallregel aktiviert oder deaktiviert ist.

Suchen Sie in der Google Cloud Console im Bereich Erzwingung nach Aktiviert oder Deaktiviert.

Suchen Sie in der Ausgabe der gcloud CLI nach dem Feld disabled. Bei disabled:false ist die Regel aktiviert und wird erzwungen. Bei disabled: true ist die Regel deaktiviert.

Welche Regel wird auf eine VM-Instanz angewendet?

Nachdem Sie eine Regel erstellt haben, können Sie prüfen, ob sie für eine bestimmte Instanz korrekt angewendet wird. Weitere Informationen finden Sie unter Firewallregeln für eine Netzwerkschnittstelle einer VM-Instanz auflisten.

VPC-Firewallregeln mit Quelltags werden nicht sofort wirksam

Firewallregeln für eingehenden Traffic, die Quelltags verwenden, benötigen etwas Zeit, bis sie wirksam werden. Weitere Informationen finden Sie in den Hinweisen zu Quelltags bei Firewallregeln für eingehenden Traffic.

Nächste Schritte

Eine Einführung in Firewallregeln finden Sie unter VPC-Firewallregeln.