VPC ファイアウォールルールを使用する

このページでは、Virtual Private Cloud（VPC）ファイアウォールルールの処理のためのコマンドについて説明し、それらの使用例を紹介します。VPC ファイアウォールルールを使用すると、ポート番号、タグ、プロトコルに基づいて、VPC ネットワーク内の仮想マシン（VM）インスタンスとの間で送受信されるトラフィックを許可または拒否できます。

始める前に

暗黙のルールやデフォルトネットワークのシステム生成ルールなど、VPC ファイアウォールルールの詳細については、VPC ファイアウォールルールをご覧ください。

ファイアウォールルールを構成する前に、ファイアウォールルールのコンポーネントを確認して、Google Cloud で使用されるファイアウォールのコンポーネントについて理解してください。

VPC ファイアウォールルールを作成する

VPC ファイアウォールルールはネットワークレベルで定義され、ルールが作成されたネットワークにのみ適用されます。ただし、それぞれの名前はプロジェクトごとに一意である必要があります。

ファイアウォールルールには IPv4 範囲または IPv6 範囲のいずれかを含めることができます。両方を含めることはできません。

ファイアウォールルールを作成する際に、ファイアウォールルールロギングを有効にするかどうかを選択できます。ロギングを有効にすると、ストレージフィールドを節約するためにメタデータフィールドを省略できます。詳細については、ファイアウォールルールロギングの使用をご覧ください。

ターゲットまたはソースのサービスアカウントのフィールドに複数のサービスアカウントを指定する場合は、Google Cloud CLI、API、またはクライアントライブラリを使用します。

デフォルトのネットワークでは、作成時に自動ファイアウォールルールが提供されます。カスタムモードと自動モードのネットワークでは、Google Cloud コンソールでネットワークを作成するときに、類似のファイアウォールを簡単に作成できます。gcloud CLI または API で、デフォルトのネットワークと類似のファイアウォールルールを作成する場合は、一般的なユースケース向けのファイアウォールルールを構成するをご覧ください。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

コンソール

Google Cloud コンソールで [ファイアウォールポリシー] ページに移動します。

[ファイアウォールポリシー] に移動
[ファイアウォールルールを作成] をクリックします。
ファイアウォールルールの [名前] を入力します。

この名前は、プロジェクト内で一意にする必要があります。
（省略可）ファイアウォールルールロギングを有効にできます。
- [ログ] > [オン] をクリックします。
- メタデータを省略するには、[ログの詳細を表示] をクリックして [メタデータを含める] チェックボックスをオフにします。
ファイアウォールルールの [ネットワーク] を指定します。
ルールの [優先度] を指定します。

数字が小さいほど、優先度が高くなります。
[トラフィックの方向] には、上り（内向き）と下り（外向き）のいずれかを選択します。
[一致したときのアクション] には、許可と拒否のいずれかを選択します。
ルールの [ターゲット] を指定します。
- ネットワーク内のすべてのインスタンスにルールを適用する場合は、[All instances in the network] を選択します。
- ネットワーク（ターゲット）のタグを使用して一部のインスタンスにルールを適用する場合は、[指定されたターゲットタグ] を選択し、[ターゲットタグ] フィールドでルールを適用するタグを入力します。
- 関連するサービスアカウントで一部のインスタンスにルールを適用する場合は、[指定されたサービスアカウント] を選択し、サービスアカウントが現在のプロジェクトにあるか、[サービスアカウントのスコープ] の別のプロジェクトにあるかを指定します。その後、[ターゲットサービスアカウント] フィールドでサービスアカウント名を選択または入力します。
上り（内向き）ルールの場合、送信元フィルタを指定します。
- 送信元 IPv4 の範囲で受信トラフィックをフィルタするには、[IPv4 範囲] を選択し、CIDR ブロックを [送信元 IPv4 範囲] フィールドに入力します。任意の IPv4 送信元の場合は、0.0.0.0/0 を使用します。
- 送信元 IPv6 の範囲で受信トラフィックをフィルタするには、[IPv6 範囲] を選択し、CIDR ブロックを [送信元 IPv6 範囲] フィールドに入力します。任意の IPv6 送信元の場合は、::/0 を使用します。
- 受信トラフィックをネットワークタグでフィルタするには、[ソースタグ] を選択し、ネットワークタグを [ソースタグ] フィールドに入力します。ソースタグ数の上限については、ネットワークごとの上限をご覧ください。ソースタグによるフィルタリングを使用できるのは、サービスアカウントによってターゲットが指定されていない場合に限られます。詳しくは、サービスアカウントによるフィルタリングとネットワークタグによるフィルタリングをご覧ください。
- サービスアカウントを使用して受信トラフィックをフィルタするには、[サービスアカウント] を選択し、[サービスアカウントのスコープ] でサービスアカウントが現在のプロジェクトにあるか、別のプロジェクトにあるかを示します。その後、[ソースのサービスアカウント] フィールドでサービスアカウント名を選択するか入力します。ソースのサービスアカウントによるフィルタリングを使用できるのは、ネットワークタグによってターゲットが指定されていない場合に限られます。詳しくは、サービスアカウントによるフィルタリングとネットワークタグによるフィルタリングをご覧ください。
- 必要に応じて、[2 番目のソースフィルタ] を指定します。2 番目のソースフィルタで、メインのソースフィルタと同じフィルタ条件を使用することはできません。ソース IP の範囲は、ソースタグまたはソースサービスアカウントと組み合わせて使用できます。有効なソースセットは、ソース範囲の IP アドレスと、ネットワークタグまたはサービスアカウントによって識別されるインスタンスを組み合わせたものです。つまり、ソース IP 範囲、またはソースタグ（またはソースサービスアカウント）のいずれかがフィルタ条件と一致する場合、そのソースは有効なソースセットに含まれています。
- [ソースタグ] と [ソースのサービスアカウント] は併用できません。
上り（内向き）ルールの場合は、送信先フィルタを指定します。
- 受信トラフィックを送信先 IPv4 範囲でフィルタするには、[IPv4 範囲] を選択し、[送信先 IPv4 範囲] フィールドに CIDR ブロックを入力します。任意の IPv4 送信先の場合は、0.0.0.0/0 を使用します。
- 受信トラフィックを送信先 IPv6 範囲でフィルタするには、[IPv6 範囲] を選択し、[送信先 IPv6 範囲] フィールドに CIDR ブロックを入力します。任意の IPv6 送信先の場合は、::/0 を使用します。詳細については、上り（内向き）ルールの送信先をご覧ください。
下り（外向き）ルールの場合は、送信先フィルタを指定します。
- 送信トラフィックを送信先 IPv4 範囲でフィルタするには、[IPv4 範囲] を選択し、[送信先 IPv4 範囲] フィールドに CIDR ブロックを入力します。任意の IPv4 送信先の場合は、0.0.0.0/0 を使用します。
- 送信トラフィックを送信先 IPv6 範囲でフィルタするには、[IPv6 範囲] を選択し、[送信先 IPv6 範囲] フィールドに CIDR ブロックを入力します。任意の IPv6 送信先の場合は、::/0 を使用します。
下り（外向き）ルールの場合、送信元フィルタを指定します。
- 送信元 IPv4 の範囲で送信トラフィックをフィルタするには、[IPv4 範囲] を選択し、CIDR ブロックを [送信元 IPv4 範囲] フィールドに入力します。任意の IPv4 送信元の場合は、0.0.0.0/0 を使用します。
- 送信元 IPv6 の範囲で送信トラフィックをフィルタするには、[IPv6 範囲] を選択し、CIDR ブロックを [送信元 IPv6 範囲] フィールドに入力します。任意の IPv6 送信先の場合は、::/0 を使用します。詳細については、下り（外向き）ルールの送信元をご覧ください。
ルールを適用するプロトコルとポートを定義します。
- すべてのプロトコルと宛先ポートにルールを適用する場合は、アクションに応じて [すべて許可] または [すべて拒否] を選択します。
- 特定のプロトコルと宛先ポートを定義するには、[指定したプロトコルとポート] を選択します。
  - TCP のプロトコルと宛先ポートを指定する場合は [TCP] を選択します。「all」と入力するか、20-22, 80, 8080 などの宛先ポートのカンマ区切りのリストを入力します。
  - UDP のプロトコルと宛先ポートを指定するには [UDP] を選択します。「all」と入力するか、67-69, 123 などの宛先ポートのカンマ区切りのリストを入力します。
  - icmp や sctp などのプロトコル、またはプロトコル番号を含めるには [その他] を選択します。たとえば、IPv4 ICMP には icmp またはプロトコル番号 1 を使用します。IPv6 ICMP にはプロトコル番号 58 を使用します。
    
    詳細については、プロトコルと宛先ポートをご覧ください。
（省略可）ファイアウォールルールを作成しても、その適用状態を無効に設定すれば、ルールは適用されません。[ルールを無効にする] をクリックし、[無効] を選択します。
[作成] をクリックします。

gcloud

VPC ファイアウォールルールを作成するには、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]

パラメータは以下のように使用します。各パラメータの詳細については、SDK リファレンスドキュメントをご覧ください。

--network: ルールのネットワーク。省略した場合、ルールは default ネットワークに作成されます。デフォルトネットワークがない場合や、特定のネットワークにルールを作成する場合は、このフィールドを使用する必要があります。
--priority: ルールの優先度を示す数値です。数字が小さいほど、優先度が高くなります。
--direction: トラフィックの方向です。ingress か egress のいずれかを指定します。
--action: 一致したときのアクションです。allow か deny のいずれかを指定します。--rules フラグとともに使用する必要があります。
次のいずれかの方法でターゲットを指定します。
- ルールをネットワーク内のすべてのターゲットに適用する場合は、--target-tags と --target-service-accounts を省略します。
- ネットワークタグを使用してターゲットを定義するには、--target-tags フラグを使用します。
- 関連するサービスアカウントによってターゲットを定義するには、--target-service-accounts フラグを使用します。
上り（内向き）ルールで送信先をさらに絞り込むには、--destination-ranges を使用して IPv4 または IPv6 アドレス範囲を CIDR 形式で指定します。--destination-ranges が省略されている場合、上り（内向き）の送信先は任意の IPv4 アドレス（0.0.0.0/0）になります。詳細については、上り（内向き）ルールの送信先と上り（内向き）ルールのターゲットと IP アドレスをご覧ください。
上り（内向き）ルールの場合は、送信元を指定します。
- --source-ranges: 送信元 IPv4 または IPv6 アドレスの範囲を CIDR 形式で指定する場合は、このフラグを使用します。
- --source-ranges、source-tags、--source-service-accounts が省略されている場合、上り（内向き）のソースは任意の IPv4 アドレス（0.0.0.0/0）になります。
- --source-tags: ネットワークタグを使用してソースインスタンスを指定する場合は、このフラグを使用します。ソースタグによるフィルタリングを使用できるのは、サービスアカウントによってターゲットが指定されていない場合に限られます。詳しくは、サービスアカウントによるフィルタリングとネットワークタグによるフィルタリングをご覧ください。
- --source-ranges と --source-tags は併用できます。両方が指定されている場合、有効なソースセットは、ソース範囲の IP アドレスと、ネットワークタグによって特定されるインスタンスを組み合わせたものです（タグ付けされたインスタンスがソース範囲の IP を持たない場合であっても対象に含まれます）。
- --source-service-accounts: 使用するサービスアカウントでインスタンスを指定する場合は、このフラグを使用します。ソースのサービスアカウントによるフィルタリングを使用できるのは、ネットワークタグによってターゲットが指定されていない場合に限られます。詳しくは、サービスアカウントによるフィルタリングとネットワークタグによるフィルタリングをご覧ください。--source-ranges と --source-service-accounts は併用できます。両方が指定されている場合、有効なソースセットは、ソース範囲の IP アドレスと、ソースのサービスアカウントによって特定されるインスタンスを組み合わせたものです（ソースのサービスアカウントによって特定されるインスタンスがソース範囲の IP を持たない場合であっても対象に含まれます）。
下り（外向き）ルールで送信元をさらに絞り込むには、--source-ranges を使用して IPv4 または IPv6 アドレス範囲を CIDR 形式で指定します。--source-ranges が省略されている場合、下り（外向き）の送信元は任意の IPv4 アドレス（0.0.0.0/0）になります。詳細については、下り（外向き）ルールの送信元と下り（外向き）ルールのターゲットと IP アドレスをご覧ください。
下り（外向き）ルールの場合は送信先を指定します。
- --destination-ranges: 送信先 IPv4 または IPv6 アドレスの範囲を CIDR 形式で指定する場合は、このフラグを使用します。
- --destination-ranges が省略されている場合、下り（外向き）の宛先は任意の IPv4 アドレス（0.0.0.0/0）になります。
--rules: ルールの適用対象となるプロトコルとポートのリスト。すべてのプロトコルと宛先ポートにルールを適用する場合は、all を使用します。--action フラグが必要です。
デフォルトでは、ファイアウォールルールが作成されると自動的に適用されますが、この動作は変更できます。
- --disabled と --no-disabled の両方が省略されている場合は、ファイアウォールルールが作成され、適用されます。
- --disabled: ファイアウォールルールを作成して適用しない場合は、このフラグを追加します。ファイアウォールルールを更新して有効にするまで、ファイアウォールルールは無効のままです。
- --no-disabled: ファイアウォールルールを確実に適用するには、このフラグを追加します。
--enable-logging | --no-enable-logging ファイアウォールルールロギングは、ルールの作成時、更新時に適用できます。ファイアウォールルールロギングを使用すると、ファイアウォールルールの効果を監査、検証、分析できます。詳しくは、ファイアウォールルールのロギングをご覧ください
- --logging-metadata: ロギングを有効にすると、デフォルトでは、ファイアウォールルールのロギングにベースフィールドとメタデータフィールドが含まれます。ストレージ費用を節約するために、メタデータフィールドを省略できます。詳細については、ファイアウォールルールロギングの使用をご覧ください。

Terraform

ファイアウォールルールを作成するには、google_compute_firewall リソースを使用します。

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

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

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

Terraform 構成を適用または削除する方法については、基本的な Terraform コマンドをご覧ください。

API

VPC ファイアウォールルールを作成します。

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

次のように置き換えます。

PROJECT_ID: VPC ネットワークが配置されているプロジェクトの ID。
NETWORK: ファイアウォールルールを作成する VPC ネットワークの名前。
RULE_NAME: ファイアウォールルールの名前。
上り（内向き）ファイアウォールルールの場合は、上り（内向き）の送信元と送信先を指定します。
- sourceRanges、sourceTags、または sourceServiceAccounts フィールドを使用して、上り（内向き）の送信元を指定します。
- sourceRanges は、IPv4 と IPv6 のどちらの範囲でも指定できます。ただし、両方を組み合わせることはできません。範囲 0.0.0.0/0 を使用する場合は、フィールドを指定しないでください。
- sourceTags フィールドと sourceServiceAccounts フィールドは併用できません。ただし、sourceRanges は sourceTags または sourceServiceAccounts と併用できます。その場合、ファイアウォールルールを適用するには、接続がどちらか一方と一致する必要があります。
- ターゲットフィールドで sourceTags フィールドを使用している場合は、targetServiceAccounts フィールドを使用できません。targetTags フィールドを使用するか、ターゲットフィールドは使用しないでください。同様に、sourceServiceAccounts フィールドを使用している場合、targetTags フィールドは使用できません。ターゲットフィールドを指定しない場合、ルールはネットワーク内のすべてのターゲットに適用されます。
- destinationRanges フィールドを使用して、上り（内向き）の送信先を指定します。destinationRanges は、IPv4 と IPv6 のどちらの範囲でも指定できます。ただし、両方を組み合わせることはできません。
  送信先を指定しない場合、Google Cloud は 0.0.0.0/0 を使用します。詳細については、上り（内向き）ルールの送信先と上り（内向き）ルールのターゲットと IP アドレスをご覧ください。
下り（外向き）ファイアウォールルールの場合、下り（外向き）の送信元と送信先を指定します。
- sourceRanges フィールドを使用して、下り（外向き）の送信元を指定します。sourceRange は、IPv4 と IPv6 のどちらの範囲でも指定できます。ただし、両方を組み合わせることはできません。
  送信元を指定しない場合、Google Cloud は 0.0.0.0/0 を使用します。詳細については、下り（外向き）ルールの送信元と下り（外向き）ルールのターゲットと IP アドレスをご覧ください。
- destinationRanges フィールドを使用して、送信先を指定します。destinationRanges は、IPv4 と IPv6 のどちらの範囲でも指定できます。ただし、両方を組み合わせることはできません。
  送信先を指定しない場合、Google Cloud は 0.0.0.0/0 を使用します。targetTags または targetServiceAccounts フィールドを使用して、ルールを適用するターゲットを指定します。ターゲットフィールドを指定しない場合、ルールはネットワーク内のすべてのターゲットに適用されます。

各フィールドの詳細と説明については、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 ファイアウォールルールを更新する

条件を一致させるために、指定されたプロトコルや宛先ポートなど、VPC ファイアウォールルールのコンポーネントの一部を変更できます。ファイアウォールルールの名前、ネットワーク、一致したときのアクション、トラフィックの方向は変更できません。

名前、ネットワーク、アクション、方向のコンポーネントを変更する必要がある場合は、ルールを削除して新しいルールを作成する必要があります。

複数のサービスアカウントを追加または削除する場合は、gcloud CLI、API、またはクライアントライブラリを使用します。Google Cloud コンソールを使用して、複数のターゲットサービスアカウントまたはソースサービスアカウントを指定することはできません。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.update

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

コンソール

Google Cloud コンソールで [ファイアウォールポリシー] ページに移動します。

[ファイアウォールポリシー] に移動
変更するファイアウォールルールをクリックします。
[編集] をクリックします。
いずれかの編集可能コンポーネントをニーズに合うように変更します。
[保存] をクリックします。

gcloud

VPC ファイアウォールルールを更新するには、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]

各フラグの説明は、ファイアウォールルールを作成での説明と同じです。各フラグの詳細については、SDK リファレンスドキュメントをご覧ください。

API

PATCH を使用して、フィールド allowed、description、sourceRanges、sourceTags、または targetTags を更新します。それ以外のフィールドには PUT または POST を使用します。

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

次のように置き換えます。

PROJECT_ID: VPC ネットワークが配置されているプロジェクトの ID。
NETWORK: ファイアウォールルールを配置する VPC ネットワークの名前。
RULE_NAME: 更新するファイアウォールルールの名前。

各フィールドの詳細と説明については、firewalls.patch または 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 ネットワークの VPC ファイアウォールルールを一覧表示する

プロジェクトまたは特定の VPC ネットワークのすべての VPC ファイアウォールルールを一覧表示できます。ファイアウォールルールごとに、Google Cloud にルールのタイプ、ターゲット、フィルタなどの詳細が表示されます。

ファイアウォールルールロギングを有効にすると、ファイアウォールインサイトでファイアウォールルールに関する分析情報が示されるため、構成の理解を深め、より安全に最適化できます。たとえば、過去 6 週間に使用されていない allow ルールを確認できます。詳細については、ファイアウォールインサイトのドキュメントにあるファイアウォールルールの詳細画面の使用をご覧ください。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.list

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）
Compute ネットワーク管理者（roles/compute.networkAdmin）
Compute ネットワーク閲覧者（roles/compute.networkViewer）
Compute 閲覧者（roles/compute.viewer）

コンソール

プロジェクト内のすべてのネットワークの VPC ファイアウォールルールをすべて表示するには:

Google Cloud コンソールで [ファイアウォールポリシー] ページに移動します。

[ファイアウォールポリシー] に移動

特定のネットワーク内の VPC ファイアウォールルールを表示するには:

Google Cloud コンソールの [VPC ネットワーク] ページに移動します。

[VPC ネットワーク] に移動
VPC ネットワークの名前をクリックして、その詳細ページに移動します。
ネットワークの詳細ページで、[ファイアウォール] タブをクリックします。
vpc-firewall-rules を開きます。

gcloud

特定のネットワークの VPC ファイアウォールルールを並べ替えてリストを作成するには、gcloud compute firewall-rules list コマンドを使用します。

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

NETWORK は、ファイアウォールルールを一覧表示するネットワークの名前に置き換えます。

API

指定されたネットワークのすべての VPC ファイアウォールルールを一覧表示します。

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

次のように置き換えます。

PROJECT_ID: VPC ネットワークが配置されているプロジェクトの ID。
NETWORK: 一覧表示するファイアウォールルールを含む VPC ネットワークの名前。

詳細については、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

VM インスタンスのネットワークインターフェースの VPC ファイアウォールルールを一覧表示する

Google Cloud コンソールには、インターフェースに適用されるすべての VPC ファイアウォールルールと、実際にインターフェースで使用されているルールの一覧がネットワークインターフェースごとに表示されます。ファイアウォールルールは他のルールをマスキングできるため、インターフェースに適用されるすべてのルールが実際にインターフェースで使用されないことがあります。

ファイアウォールルールは、ルールの対象パラメータを使用して VM インスタンスに関連付けられ、適用されます。適用されているすべてのルールを表示して、特定のルールがインターフェースに適用されているかどうかを確認できます。

ファイアウォールルールロギングを有効にすると、ファイアウォールインサイトでファイアウォールルールに関する分析情報が示されるため、構成の理解を深め、より安全に最適化できます。たとえば、過去 6 週間にインターフェースでヒットしたルールを確認できます。詳細については、ファイアウォールインサイトのドキュメントにある VM ネットワークインターフェースの詳細画面の使用をご覧ください。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.list

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）
Compute ネットワーク管理者（roles/compute.networkAdmin）
Compute ネットワーク閲覧者（roles/compute.networkViewer）
Compute 閲覧者（roles/compute.viewer）

コンソール

VM インスタンスの特定のネットワークインターフェースに適用される VPC ルールを表示するには:

Google Cloud コンソールで [VM インスタンス] ページに移動します。

[VM インスタンス] に移動
表示するインスタンスを見つけます。
インスタンスの [その他の操作] メニュー（）で、[ネットワークの詳細の表示] を選択します。
インスタンスに複数のネットワークインターフェースがある場合は、[選択したネットワークインターフェース] フィールドに表示するネットワークインターフェースを選択します。
[ファイアウォールとルートの詳細] セクションで、[ファイアウォール] タブを選択します。
vpc-firewall-rules を開きます。
この表で、特定の IP アドレスとの間のトラフィックが許可されているかどうかを確認します。

VPC ファイアウォールルールの詳細を表示する

VPC ファイアウォールルールを調べると、名前、適用されるネットワーク、コンポーネントなどの情報を確認できます（ルールの有効 / 無効も確認できます）。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.get

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）
Compute ネットワーク管理者（roles/compute.networkAdmin）
Compute ネットワーク閲覧者（roles/compute.networkViewer）
Compute 閲覧者（roles/compute.viewer）

コンソール

ファイアウォールルールを一覧表示します。すべてのルールのリスト、または特定のネットワーク内のルールのみを表示できます。
表示するルールをクリックします。

gcloud

次のコマンドを実行すると、個別の VPC ファイアウォールルールの情報が取得できます。ファイアウォールルールの名前はプロジェクトで一意であるため、既存のファイアウォールルールの情報を出力する場合、ネットワークを指定する必要はありません。

gcloud compute firewall-rules describe RULE_NAME

RULE_NAME の部分は、ファイアウォールルールの名前に置き換えます。

API

特定の VPC ファイアウォールルールの説明を取得します。

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

プレースホルダを有効な値に置き換えます。

PROJECT_ID: ファイアウォールルールが配置されているプロジェクトの ID。
RULE_NAME: 記述するファイアウォールルールの名前。

詳細については、firewalls.get メソッドをご覧ください。

VPC ファイアウォールルールを削除する

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.delete

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

コンソール

VPC ファイアウォールルールを一覧表示します。すべてのルールのリスト、または特定のネットワーク内のルールのみを表示できます。
削除するルールをクリックします。
[削除] をクリックします。
もう一度 [削除] をクリックして確定します。

gcloud

VPC ファイアウォールルールを削除するには、gcloud compute firewall-rules delete コマンドを使用します。

gcloud compute firewall-rules delete RULE_NAME

RULE_NAME は、削除するルールの名前に置き換えます。

API

VPC ファイアウォールルールを削除します。

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

次のように置き換えます。

PROJECT_ID: ファイアウォールルールが配置されているプロジェクトの ID。
RULE_NAME: 削除するファイアウォールルールの名前。

詳細については、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 ファイアウォールルールをモニタリングする

VPC ファイアウォールルールのロギングを有効にして、どのルールがどのトラフィックを許可またはブロックしているかを確認できます。詳しくは、ファイアウォールルールロギングの使用をご覧ください。

一般的なユースケースの VPC ファイアウォールルールを構成する

以下のセクションでは、gcloud CLI と API を使用して、デフォルトのネットワーク用に作成された事前定義の VPC ファイアウォールルールを再作成する例を示します。この例を使用すると、カスタムモードと自動モードのネットワークに同様のルールを作成できます。各ファイアウォールルールには IPv4 か IPv6 アドレス範囲のいずれかを含めることができます。両方を含めることはできません。

VM 間の内部上り（内向き）接続を許可する

次の例では、VM インスタンスへの内部 TCP、UDP、ICMP 接続を許可するファイアウォールルールを作成します。これは、デフォルトのネットワークの allow-internal ルールと類似しています。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

gcloud compute firewall-rules create コマンドを使用します。

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

次のように置き換えます。

RULE_NAME: このファイアウォールルールの名前。
NETWORK: ファイアウォールルールが適用されるネットワークの名前。デフォルト値は default です。
ICMP_PROTOCOL: ICMP プロトコルタイプ。プロトコル名 icmp またはプロトコル番号 1 を使用して、ICMPv4 を指定します。プロトコル番号 58 を使用して ICMPv6 を指定します。
SUBNET_RANGES: 1 つ以上の IP アドレス範囲。IP アドレス範囲を指定すると、その範囲からのトラフィックは VPC ネットワーク内の任意の VM 宛先に到達できます。ファイアウォールルールには、IPv4 範囲か IPv6 範囲のいずれかを指定できます。

IPv4 サブネット範囲:
- 自動モードの VPC ネットワークは、10.128.0.0/9 内の IP アドレス範囲を使用します。
- カスタムモードのネットワークは、任意の有効な IPv4 範囲を使用できます。VPC ネットワークのサブネットに隣接した範囲を使用しない場合は、複数の範囲の指定が必要になることがあります。
- 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 を使用して、すべてのプライベート IPv4 アドレス範囲（RFC 1918 範囲）からのトラフィックを許可できます。
IPv6 サブネット範囲:
- VPC ネットワークに内部 IPv6 アドレス範囲を割り当てている場合は、その範囲をソース範囲として使用できます。VPC ネットワークの内部 IPv6 範囲を使用すると、ファイアウォールルールには、現在と将来のすべての内部 IPv6 サブネット範囲が設定されます。VPC ネットワークの内部 IPv6 の範囲は、次のコマンドを使用して確認できます。
```
gcloud compute networks describe NETWORK \
  --format="flattened(internalIpv6Range)"
```
  特定の内部 IPv6 サブネット範囲を指定することもできます。
- デュアルスタックサブネットの外部 IPv6 サブネット範囲からのトラフィックを許可するには、対象に含める各サブネットの IPv6 アドレス範囲を指定する必要があります。

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

次のように置き換えます。

PROJECT_ID: VPC ネットワークが配置されているプロジェクトの ID。
RULE_NAME: ファイアウォールルールの名前。
NETWORK: ファイアウォールルールを作成する VPC ネットワークの名前。デフォルト値は default です。
ICMP_PROTOCOL: ICMP プロトコルタイプ。プロトコル名 icmp またはプロトコル番号 1 を使用して、ICMPv4 を指定します。プロトコル番号 58 を使用して ICMPv6 を指定します。
INTERNAL_SOURCE_RANGES: 1 つ以上の IP 範囲。VPC ネットワークのすべてのサブネット内の内部トラフィックを許可するには、VPC ネットワークで使用される IP アドレス範囲を指定します。ファイアウォールルールには、IPv4 範囲か IPv6 範囲のいずれかを指定できます。

IPv4 サブネット範囲:
- 自動モードの VPC ネットワークは、10.128.0.0/9 内の IP アドレス範囲を使用します。
- カスタムモードのネットワークは、任意の有効な IPv4 範囲を使用できます。VPC ネットワークのサブネットに隣接した範囲を使用しない場合は、複数の範囲の指定が必要になることがあります。
- 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 を使用して、すべてのプライベート IPv4 アドレス範囲（RFC 1918 範囲）からのトラフィックを許可できます。
IPv6 サブネット範囲:
- VPC ネットワークに内部 IPv6 アドレス範囲を割り当てている場合は、その範囲をソース範囲として使用できます。VPC ネットワークの内部 IPv6 範囲を使用すると、ファイアウォールルールには、現在と将来のすべての内部 IPv6 サブネット範囲が設定されます。VPC ネットワークの内部 IPv6 の範囲は、次のコマンドを使用して確認できます。
```
gcloud compute networks describe NETWORK \
  --format="flattened(internalIpv6Range)"
```
  特定の内部 IPv6 サブネット範囲を指定することもできます。
- デュアルスタックサブネットの外部 IPv6 サブネット範囲からのトラフィックを許可するには、対象に含める各サブネットの IPv6 アドレス範囲を指定する必要があります。

VM への上り（内向き）SSH 接続を許可する

次の例では、VM インスタンスへの SSH 接続を許可するファイアウォールルールを作成します。これは、デフォルトのネットワークの allow-ssh ルールと類似しています。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

gcloud compute firewall-rules create コマンドを使用します。

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

次のように置き換えます。

RULE_NAME: このファイアウォールルールの名前。
NETWORK: ファイアウォールルールが適用されるネットワークの名前。デフォルト値は default です。
RANGES_OUTSIDE_VPC_NETWORK: 1 つ以上の IP アドレス範囲。ファイアウォールルールには、IPv4 範囲か IPv6 範囲のいずれかを指定できます。すべての IPv4 または IPv6 ソースではなく、アクセスを許可する必要がある特定の IP アドレス範囲を指定することをおすすめします。
- ソース範囲に 35.235.240.0/20 を含めると、他のすべての前提条件が満たされている場合に、Identity-Aware Proxy（IAP）TCP 転送を使用した SSH 接続が許可されます。詳細については、TCP 転送での IAP の使用をご覧ください。
- ソース範囲として 0.0.0.0/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv4 ソースからのトラフィックが許可されます。
- ソース範囲として ::/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv6 ソースからのトラフィックが許可されます。

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

次のように置き換えます。

PROJECT_ID: VPC ネットワークが配置されているプロジェクトの ID。
RULE_NAME: ファイアウォールルールの名前。
NETWORK: ファイアウォールルールを作成する VPC ネットワークの名前。
RANGES_OUTSIDE_VPC_NETWORK: 1 つ以上の IP アドレス範囲。ファイアウォールルールには、IPv4 範囲か IPv6 範囲のいずれかを指定できます。すべての IPv4 または IPv6 ソースではなく、アクセスを許可する必要がある特定の IP アドレス範囲を指定することをおすすめします。
- ソース範囲に 35.235.240.0/20 を含めると、他のすべての前提条件が満たされている場合に、Identity-Aware Proxy（IAP）TCP 転送を使用した SSH 接続が許可されます。詳細については、TCP 転送での IAP の使用をご覧ください。
- ソース範囲として 0.0.0.0/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv4 ソースからのトラフィックが許可されます。
- ソース範囲として ::/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv6 ソースからのトラフィックが許可されます。

VM への上り（内向き）RDP 接続を許可する

次の例では、VM インスタンスへの Microsoft リモートデスクトッププロトコル（RDP）接続を許可するファイアウォールルールを作成します。これは、デフォルトのネットワークの allow-rdp ルールと類似しています。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

gcloud compute firewall-rules create コマンドを使用します。

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

次のように置き換えます。

RULE_NAME: このファイアウォールルールの名前。
NETWORK: ファイアウォールルールが適用されるネットワークの名前。デフォルト値は default です。
RANGES_OUTSIDE_VPC_NETWORK: 1 つ以上の IP アドレス範囲。ファイアウォールルールには、IPv4 範囲か IPv6 範囲のいずれかを指定できます。すべての IPv4 または IPv6 ソースではなく、アクセスを許可する必要がある特定の IP アドレス範囲を指定することをおすすめします。
- ソース範囲に 35.235.240.0/20 を含めると、他のすべての前提条件が満たされている場合に、Identity-Aware Proxy（IAP）TCP 転送を使用した RDP 接続が許可されます。詳細については、TCP 転送での IAP の使用をご覧ください。
- ソース範囲として 0.0.0.0/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv4 ソースからのトラフィックが許可されます。
- ソース範囲として ::/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv6 ソースからのトラフィックが許可されます。

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

次のように置き換えます。

PROJECT_ID: VPC ネットワークが配置されているプロジェクトの ID。
RULE_NAME: ファイアウォールルールの名前。
NETWORK: ファイアウォールルールを作成する VPC ネットワークの名前。
RANGES_OUTSIDE_VPC_NETWORK: 1 つ以上の IP アドレス範囲。ファイアウォールルールには、IPv4 範囲か IPv6 範囲のいずれかを指定できます。すべての IPv4 または IPv6 ソースではなく、アクセスを許可する必要がある特定の IP アドレス範囲を指定することをおすすめします。
- ソース範囲に 35.235.240.0/20 を含めると、他のすべての前提条件が満たされている場合に、Identity-Aware Proxy（IAP）TCP 転送を使用した RDP 接続が許可されます。詳細については、TCP 転送での IAP の使用をご覧ください。
- ソース範囲として 0.0.0.0/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv4 ソースからのトラフィックが許可されます。
- ソース範囲として ::/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv6 ソースからのトラフィックが許可されます。

VM への上り（内向き）ICMP 接続を許可する

次の例では、VM インスタンスへの ICMP 接続を許可するファイアウォールルールを作成します。これは、デフォルトのネットワークの allow-icmp ルールと類似しています。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

gcloud compute firewall-rules create コマンドを使用します。

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

次のように置き換えます。

RULE_NAME: ファイアウォールルールの名前。
NETWORK: ファイアウォールルールが適用されるネットワークの名前。デフォルト値は default です。
ICMP_PROTOCOL: ICMP プロトコルタイプ。プロトコル名 icmp またはプロトコル番号 1 を使用して、ICMPv4 を指定します。プロトコル番号 58 を使用して ICMPv6 を指定します。
RANGES_OUTSIDE_VPC_NETWORK: 1 つ以上の IP アドレス範囲。ファイアウォールルールには、IPv4 範囲か IPv6 範囲のいずれかを指定できます。すべての IPv4 または IPv6 ソースではなく、アクセスを許可する必要がある特定の IP アドレス範囲を指定することをおすすめします。
- ソース範囲として 0.0.0.0/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv4 ソースからのトラフィックが許可されます。
- ソース範囲として ::/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv6 ソースからのトラフィックが許可されます。

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

次のように置き換えます。

PROJECT_ID: VPC ネットワークが配置されているプロジェクトの ID。
RULE_NAME: ファイアウォールルールの名前。
NETWORK: ファイアウォールルールを作成する VPC ネットワークの名前。
ICMP_PROTOCOL: 使用する ICMP プロトコルのタイプ。プロトコル名 icmp またはプロトコル番号 1 を使用して、ICMPv4 を指定します。プロトコル番号 58 を使用して ICMPv6 を指定します。
RANGES_OUTSIDE_VPC_NETWORK: 1 つ以上の IP アドレス範囲。ファイアウォールルールには、IPv4 範囲か IPv6 範囲のいずれかを指定できます。すべての IPv4 または IPv6 ソースではなく、アクセスを許可する必要がある特定の IP アドレス範囲を指定することをおすすめします。
- ソース範囲として 0.0.0.0/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv4 ソースからのトラフィックが許可されます。
- ソース範囲として ::/0 を使用すると、Google Cloud の外部にあるソースを含むすべての IPv6 ソースからのトラフィックが許可されます。

その他の構成例

図 1 は、my-network という名前の VPC ネットワークの構成例を示しています。このネットワークには次のものが存在します。

IP 範囲が 10.240.10.0/24 の subnet1 という名前のサブネット。単一のインスタンスが存在します。
IP 範囲が 192.168.1.0/24 の subnet2 という名前のサブネット。
subnet2 の vm1 という名前のインスタンス。タグ webserver、内部 IP アドレス 192.168.1.2 が設定されています。
subnet2 の vm2 という名前のインスタンス。タグ database、内部 IP アドレス 192.168.1.3 が設定されています。

この VPC ネットワークには 2 つのサブネットがあり、それぞれに VM が含まれています。subnet2 には、ネットワークタグが割り当てられている VM が含まれます。 — **図 1.** この VPC ネットワークには 2 つのサブネットがあり、それぞれに VM が含まれています。subnet2 には、ネットワークタグが割り当てられている VM が含まれます（クリックして拡大）。

例 1: subnet1 からポート 80 への接続を除くすべての上り（内向き）TCP 接続を拒否する

この例では、subnet1 からポート 80 への接続を除くすべての上り（内向き）TCP 接続を拒否する VPC ファイアウォールルールのセットを作成します。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

webserver でタグ付けされたインスタンスへのすべての上り（内向き）TCP トラフィックを拒否するファイアウォールルールを作成します。
```
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
```
NETWORK_NAME は、ネットワークの名前に置き換えます。
subnet1（10.240.10.0/24）に、すべての IP アドレスを許可するファイアウォールルールを作成し、webserver というタグの付いたインスタンスの TCP ポート 80 へのアクセスを許可します。
```
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
```
NETWORK_NAME は、ネットワークの名前に置き換えます。

例 2: vm1 のポート 80 への接続を除くすべての下り（外向き）TCP 接続を拒否する

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

すべての下り（外向き）TCP トラフィックを拒否するファイアウォールルールを作成します。

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

NETWORK_NAME は、ネットワークの名前に置き換えます。

vm1 ポート 80 への TCP トラフィックを許可するファイアウォールルールを作成します。

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

NETWORK_NAME は、ネットワークの名前に置き換えます。

例 3: 外部ホストのポート 443 への下り（外向き）TCP 接続を許可する

webserver でタグ付けされたインスタンスが、サンプル外部 IP アドレス 192.0.2.5 のポート 443 へ下り（外向き）TCP トラフィックを送信できるように許可するファイアウォールルールを作成します。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

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

NETWORK_NAME は、ネットワークの名前に置き換えます。

例 4: vm2 から vm1 への SSH 接続を許可する

タグ database（vm2）が付いたインスタンスからタグ webserver（vm1）が付いたインスタンスに到達する SSH トラフィックを許可するファイアウォールルールを作成します。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

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

NETWORK_NAME は、ネットワークの名前に置き換えます。

例 5: サービスアカウントを使用し、ウェブサーバーからデータベースへの TCP: 1443 を許可する

サービスアカウントとロールの詳細については、サービスアカウントにロールを付与するをご覧ください。

テンプレートを介して自動スケーリングされる 2 つのアプリケーションがある図 2 のシナリオを考えてみます。my-sa-webserver サービスアカウントに関連付けられたウェブサーバーアプリケーションと、my-sa-database サービスアカウントに関連付けられたデータベースアプリケーションです。セキュリティ管理者は、my-sa-webserver サービスアカウントを持つ VM から my-sa-database サービスアカウントを持つ VM の宛先ポート 1443 への TCP トラフィックを許可しようと考えています。

ファイアウォールルールは、サービスアカウント my-sa-webserver を持つ VM から、サービスアカウント my-sa-database を持つ VM のポート 1443 へのトラフィックを許可します。 — **図 2.** ファイアウォールルールは、サービスアカウント my-sa-webserver を持つ VM から、サービスアカウント my-sa-database を持つ VM のポート 1443 へのトラフィックを許可します（クリックして拡大）。

サービスアカウントの作成を含む構成手順は次のとおりです。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.create

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）

gcloud

プロジェクトの編集者またはオーナーが、my-sa-webserver と 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"

プロジェクトオーナーが Identity and Access Management（IAM）ポリシーを設定して、ウェブサーバーのデベロッパー web-dev@example.com にサービスアカウント my-sa-webserver の serviceAccountUser のロールを割り当てます。
```
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'
```
プロジェクトオーナーが IAM ポリシーを設定して、データベースデベロッパー db-dev@example.com にサービスアカウント my-sa-database の serviceAccountUser のロールを割り当てます。
```
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'
```
インスタンス管理者のロールを持つデベロッパー web-dev@example.com が、ウェブサーバーインスタンステンプレートを作成し、インスタンスをサービスアカウント my-sa-webserver として実行する権限を与えます。
```
gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --service-account my-sa-webserver@my-project-123.iam.gserviceaccount.com
```
インスタンス管理者のロールを持つデベロッパー db-dev@example.com が、データベースインスタンステンプレートを作成し、インスタンスをサービスアカウント my-sa-database として実行する権限を与えます。
```
gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --service-account my-sa-database@my-project-123.iam.gserviceaccount.com
```
セキュリティ管理者は、TCP トラフィックがサービスアカウント my-sa-webserver の VM からサービスアカウント my-sa-database の VM のポート 1443 に到達することを許可するファイアウォールルールを作成します。
```
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
```

トラブルシューティング

VPC ファイアウォールルールの作成または更新時のエラーメッセージ

以下のエラーメッセージのいずれかが表示される場合があります。

Should not specify destination range for ingress direction.

送信先の範囲が、上り（内向き）のファイアウォールルールの有効なパラメータではありません。ファイアウォールルールは、egress の方向が特に指定されていない限り、上り（内向き）ルールとみなされます。方向を指定せずにルールを作成すると、上り（内向き）ルールとして作成され、宛先の範囲は許可されません。また、送信元の範囲も下り（外向き）ルールの有効なパラメータではありません。
Firewall direction cannot be changed once created.

既存のファイアウォールルールの方向は変更できません。正しいパラメータで新しいルールを作成してから、古いルールを削除する必要があります。
Firewall traffic control action cannot be changed once created.

既存のファイアウォールルールのアクションは変更できません。正しいパラメータで新しいルールを作成してから、古いルールを削除する必要があります。

Service accounts must be valid RFC 822 email addresses. ファイアウォールルールで指定するサービスアカウントは、RFC 822 形式のメールアドレスである必要があります。

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

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

ServiceAccounts and Tags are mutually exclusive and can't be combined in the same firewall rule. 同じルール内にサービスアカウントとタグの両方を指定することはできません。

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.

リソースが見つからないことを示すエラー

VPC ネットワークまたはファイアウォールルールを削除すると、次のようなメッセージが表示されることがあります。 The resource "aet-uscentral1-subnet--1-egrfw" was not found.

このエラーにより、暗黙のファイアウォールルールの削除や詳細の表示がブロックされる可能性があります。ファイアウォールルールがこの状態であると、VPC ネットワークの削除もブロックされる場合があります。

このようにブロックされているファイアウォールルールまたはネットワークを削除するには、関連するサーバーレス VPC アクセスコネクタを削除してから、もう一度お試しください。サーバーレス VPC アクセスコネクタを削除する方法については、コネクタを削除するをご覧ください。

ファイアウォールエラーが多すぎる

次のエラーメッセージが表示される場合があります。 Google Compute Engine: The network contains too many large firewalls.

安全性とパフォーマンスを維持するため、VPC ネットワークに実装できるファイアウォールルールの複雑さと数には上限があります。このエラーが表示された場合は、ファイアウォールルールを簡素化または統合するようにアカウント管理チームに依頼してください。

VM インスタンスに接続できない

VM インスタンスに接続できない場合、ファイアウォールルールを確認してください。

このタスクに必要な権限

このタスクを実行するには、次の権限または次の IAM ロールのいずれかが付与されている必要があります。

権限

compute.firewalls.list

ロール

Compute セキュリティ管理者（roles/compute.securityAdmin）
Compute ネットワーク管理者（roles/compute.networkAdmin）
Compute ネットワーク閲覧者（roles/compute.networkViewer）
Compute 閲覧者（roles/compute.viewer）

gcloud

別の VM インスタンスから接続を開始する場合は、そのインスタンスの下り（外向き）ファイアウォールルールを一覧表示します。

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

NETWORK_NAME は、ネットワークの名前に置き換えます。

送信先 IP がすべての下り（外向き）ルールによって拒否されているかどうかを確認します。最も高い優先度（優先度の数字が最も小さいもの）を持つルールは、優先度がより低いルールよりも優先されます。同じ優先度を持つ 2 つのルールの場合、拒否ルールのほうが優先されます。

ネットワークの上り（内向き）ファイアウォールルールに送信先 VM インスタンスが含まれているかどうか確認します。

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

NETWORK_NAME は、ネットワークの名前に置き換えます。

出力例。出力は、ファイアウォールルールのリストによって異なります。

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

上り（内向き）または下り（外向き）のファイアウォールルールによってトラフィックがドロップされているかどうかをトラブルシューティングする場合は、VPC ネットワーク内の VM インスタンスと、別の VPC ネットワークまたは Google Cloud 以外のネットワークとの間で接続テストを実施します。接続テストを実施してさまざまなシナリオのトラブルシューティングを行う方法については、接続テストの実施をご覧ください。

VPC ファイアウォールルールの有効 / 無効を確認する

ファイアウォールルールの有効 / 無効を確認するには、ファイアウォールルールの詳細を表示します。

Google Cloud コンソールの [適用] セクションで、[有効] または [無効] を探します。

gcloud CLI の出力で、disabled フィールドを探します。disabled:false の場合、ルールは有効で、適用されています。disabled: true の場合、ルールは無効です。

VM インスタンスに適用されているルールを確認する

ルールを作成したら、そのルールが特定のインスタンスに正しく適用されているかどうかを確認できます。詳細については、VM インスタンスのネットワークインターフェースのファイアウォールルールを一覧表示するをご覧ください。

ソースタグ付きの VPC ファイアウォールルールがすぐに適用されない

ソースタグを使用する上り（内向き）ファイアウォールルールが反映されるまで、時間がかかることがあります。詳しくは、上り（内向き）ファイアウォールルールのソースタグに関する考慮事項をご覧ください。

次のステップ

ファイアウォールルールの概要については、VPC ファイアウォールルールをご覧ください。

VPC ファイアウォール ルールを使用する

始める前に

VPC ファイアウォール ルールを作成する

このタスクに必要な権限

コンソール

gcloud

Terraform

API

C#

Go

Java

Node.js

PHP

Python

Ruby

VPC ファイアウォール ルールを更新する

このタスクに必要な権限

コンソール

gcloud

API

C#

Go

Java

Node.js

PHP

Python

Ruby

VPC ネットワークの VPC ファイアウォール ルールを一覧表示する

このタスクに必要な権限

コンソール

gcloud

API

C#

Go

Java

Node.js

PHP

Python

Ruby

VM インスタンスのネットワーク インターフェースの VPC ファイアウォール ルールを一覧表示する

このタスクに必要な権限

コンソール

VPC ファイアウォール ルールの詳細を表示する

このタスクに必要な権限

コンソール

gcloud

API

VPC ファイアウォール ルールを削除する

このタスクに必要な権限

コンソール

gcloud

API

C#

Go

Java

Node.js

PHP

Python

Ruby

VPC ファイアウォール ルールをモニタリングする

一般的なユースケースの VPC ファイアウォール ルールを構成する

VM 間の内部上り（内向き）接続を許可する

このタスクに必要な権限

gcloud

API

VM への上り（内向き）SSH 接続を許可する

このタスクに必要な権限

gcloud

API

VM への上り（内向き）RDP 接続を許可する

このタスクに必要な権限

gcloud

API

VM への上り（内向き）ICMP 接続を許可する

このタスクに必要な権限

gcloud

API

その他の構成例

例 1: subnet1 からポート 80 への接続を除くすべての上り（内向き）TCP 接続を拒否する

このタスクに必要な権限

VPC ファイアウォールルールを使用する

VPC ファイアウォールルールを作成する

VPC ファイアウォールルールを更新する

VPC ネットワークの VPC ファイアウォールルールを一覧表示する

VM インスタンスのネットワークインターフェースの VPC ファイアウォールルールを一覧表示する

VPC ファイアウォールルールの詳細を表示する

VPC ファイアウォールルールを削除する

VPC ファイアウォールルールをモニタリングする

一般的なユースケースの VPC ファイアウォールルールを構成する

例 5: サービスアカウントを使用し、ウェブサーバーからデータベースへの TCP: 1443 を許可する

VPC ファイアウォールルールの作成または更新時のエラーメッセージ

ファイアウォールエラーが多すぎる

VPC ファイアウォールルールの有効 / 無効を確認する

ソースタグ付きの VPC ファイアウォールルールがすぐに適用されない