コレクションでコンテンツを整理 必要に応じて、コンテンツの保存と分類を行います。

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

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

始める前に

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

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

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

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

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

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

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

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

コンソール

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

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

  2. [ファイアウォール ルールを作成] をクリックします。

  3. ファイアウォール ルールの [名前] を入力します。

    この名前は、プロジェクト内で一意にする必要があります。

  4. (省略可)ファイアウォール ルール ロギングを有効にできます。

    • [ログ] > [オン] をクリックします。
    • メタデータを省略するには、[ログの詳細を表示] をクリックして [メタデータを含める] チェックボックスをオフにします。
  5. ファイアウォール ルールの [ネットワーク] を指定します。

  6. ルールの [優先度] を指定します。

    数字が小さいほど、優先度が高くなります。

  7. [トラフィックの方向] には、上り(内向き)と下り(外向き)のいずれかを選択します。

  8. [一致したときのアクション] には、許可と拒否のいずれかを選択します。

  9. ルールの [ターゲット] を指定します。

    • ネットワーク内のすべてのインスタンスにルールを適用する場合は、[All instances in the network] を選択します。
    • ネットワーク(ターゲット)のタグを使用して一部のインスタンスにルールを適用する場合は、[指定されたターゲットタグ] を選択し、[ターゲットタグ] フィールドでルールを適用するタグを入力します。
    • 関連するサービス アカウントで一部のインスタンスにルールを適用する場合は、[指定されたサービス アカウント] を選択し、サービス アカウントが現在のプロジェクトにあるか、[サービス アカウントのスコープ] の別のプロジェクトにあるかを指定します。その後、[ターゲット サービス アカウント] フィールドでサービス アカウント名を選択または入力します。
  10. 上り(内向き)ルールの場合、送信元フィルタを指定します。

    • 送信元 IPv4 の範囲で受信トラフィックをフィルタするには、[IPv4 範囲] を選択し、CIDR ブロックを [送信元 IPv4 範囲] フィールドに入力します。任意の IPv4 送信元の場合は、0.0.0.0/0 を使用します。
    • 送信元 IPv6 の範囲で受信トラフィックをフィルタするには、[IPv6 範囲] を選択し、CIDR ブロックを [送信元 IPv6 範囲] フィールドに入力します。任意の IPv6 送信元の場合は、::/0 を使用します。
    • 受信トラフィックをネットワーク タグでフィルタするには、[ソースタグ] を選択し、ネットワーク タグを [ソースタグ] フィールドに入力します。ソースタグ数の上限については、ネットワークごとの上限をご覧ください。ソースタグによるフィルタリングを使用できるのは、サービス アカウントによってターゲットが指定されていない場合に限られます。詳しくは、サービス アカウントによるフィルタリングとネットワーク タグによるフィルタリングをご覧ください。
    • サービス アカウントを使用して受信トラフィックをフィルタするには、[サービス アカウント] を選択し、[サービス アカウントのスコープ] でサービス アカウントが現在のプロジェクトにあるか、別のプロジェクトにあるかを示します。その後、[ソースのサービス アカウント] フィールドでサービス アカウント名を選択するか入力します。ソースのサービス アカウントによるフィルタリングを使用できるのは、ネットワーク タグによってターゲットが指定されていない場合に限られます。詳しくは、サービス アカウントによるフィルタリングとネットワーク タグによるフィルタリングをご覧ください。
    • 必要に応じて、[2 番目のソースフィルタ] を指定します。2 番目のソースフィルタで、メインのソースフィルタと同じフィルタ条件を使用することはできません。ソース IP の範囲は、ソースタグまたはソースサービス アカウントと組み合わせて使用できます。有効なソースセットは、ソース範囲の IP アドレスと、ネットワーク タグまたはサービス アカウントによって識別されるインスタンスを組み合わせたものです。つまり、ソース IP 範囲、またはソースタグ(またはソースサービス アカウント)のいずれかがフィルタ条件と一致する場合、そのソースは有効なソースセットに含まれています。
    • [ソースタグ] と [ソースのサービス アカウント] は併用できません。
  11. 下り(外向き)ルールの場合は、送信先フィルタを指定します。

    • 送信トラフィックを送信先 IPv4 範囲でフィルタするには、[IPv4 範囲] を選択し、[送信先 IPv4 範囲] フィールドに CIDR ブロックを入力します。任意の IPv4 送信先の場合は、0.0.0.0/0 を使用します。
    • 送信トラフィックを送信先 IPv6 範囲でフィルタするには、[IPv6 範囲] を選択し、[送信先 IPv6 範囲] フィールドに CIDR ブロックを入力します。任意の IPv6 送信先の場合は、::/0 を使用します。
  12. ルールを適用するプロトコルとポートを定義します。

    • すべてのプロトコルと宛先ポートにルールを適用する場合は、アクションに応じて [すべて許可] または [すべて拒否] を選択します。
    • 特定のプロトコルと宛先ポートを定義するには、[指定したプロトコルとポート] を選択します。

      • TCP のプロトコルと宛先ポートを指定する場合は [TCP] を選択します。「all」と入力するか、20-22, 80, 8080 などの宛先ポートのカンマ区切りのリストを入力します。
      • UDP のプロトコルと宛先ポートを指定するには [UDP] を選択します。「all」と入力するか、67-69, 123 などの宛先ポートのカンマ区切りのリストを入力します。
      • icmpsctp などのプロトコル、またはプロトコル番号を含めるには [その他] を選択します。たとえば、IPv4 ICMP には icmp またはプロトコル番号 1 を使用します。IPv6 ICMP にはプロトコル番号 58 を使用します。

        詳細については、プロトコルと宛先ポートをご覧ください。

  13. (省略可)ファイアウォール ルールを作成しても、その適用状態を無効に設定すれば、ルールは適用されません。[ルールを無効にする] をクリックし、[無効] を選択します。

  14. [作成] をクリックします。

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: トラフィックの方向です。ingressegress のいずれかを指定します。
  • --action: 一致したときのアクションです。allowdeny のいずれかを指定します。--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-rangessource-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: ロギングを有効にすると、デフォルトでは、ファイアウォール ルールのロギングにベース フィールドとメタデータ フィールドが含まれます。ストレージ費用を節約するために、メタデータ フィールドを省略できます。詳細については、ファイアウォール ルールロギングの使用をご覧ください。

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: ファイアウォール ルールの名前。

  • 上り(内向き)ファイアウォール ルールの場合は、上り(内向き)の送信元と送信先を指定します。

    • sourceRangessourceTags、または sourceServiceAccounts フィールドを使用して、上り(内向き)の送信元を指定します。

    • sourceRanges は、IPv4 と IPv6 のどちらの範囲でも指定できます。ただし、両方を組み合わせることはできません。範囲 0.0.0.0/0 を使用する場合は、フィールドを指定しないでください。

    • sourceTags フィールドと sourceServiceAccounts フィールドは併用できません。ただし、sourceRangessourceTags または sourceServiceAccounts と併用できます。その場合、ファイアウォール ルールを適用するには、接続がどちらか一方と一致する必要があります。

    • ターゲット フィールドで sourceTags フィールドを使用している場合は、targetServiceAccounts フィールドを使用できません。targetTags フィールドを使用するか、ターゲット フィールドは使用しないでください。同様に、sourceServiceAccounts フィールドを使用している場合、targetTags フィールドは使用できません。ターゲット フィールドを指定しない場合、ルールはネットワーク内のすべてのターゲットに適用されます。

    • destinationRanges フィールドを使用して、上り(内向き)の送信先を指定します。destinationRanges は、IPv4 と IPv6 のどちらの範囲でも指定できます。ただし、両方を組み合わせることはできません。
      送信先を指定しない場合、Google Cloud は 0.0.0.0/0 を使用します。詳細については、上り(内向き)ルールの送信先上り(内向き)ルールのターゲットと IP アドレスをご覧ください。
      注: 上り(内向き)ルールの送信先 IP アドレス範囲の指定はプレビュー機能です。

  • 下り(外向き)ファイアウォール ルールの場合、下り(外向き)の送信元と送信先を指定します。

    • sourceRanges フィールドを使用して、下り(外向き)の送信元を指定します。sourceRange は、IPv4 と IPv6 のどちらの範囲でも指定できます。ただし、両方を組み合わせることはできません。
      送信元を指定しない場合、Google Cloud は 0.0.0.0/0 を使用します。詳細については、下り(外向き)ルールの送信元下り(外向き)ルールのターゲットと IP アドレスをご覧ください。
      注: 下り(外向き)ルールの送信元 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 "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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: %v", 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: %v", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %v", 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\FirewallsClient;
use Google\Cloud\Compute\V1\Allowed;
use Google\Cloud\Compute\V1\Firewall;

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

/**
 * 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.
    $operation = $firewallsClient->insert($firewallResource, $projectId);

    // 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

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:
    """
    This method will wait 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

Terraform

Terraform リソースを使用してファイアウォール ルールを作成できます。

resource "google_compute_firewall" "rules" {
  project     = var.project_id # Replace this with your project ID in quotes
  name        = "my-firewall-rule"
  network     = "default"
  description = "Creates firewall rule targeting tagged instances"

  allow {
    protocol = "tcp"
    ports    = ["80", "8080", "1000-2000"]
  }
  target_tags = ["web"]
}

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

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

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

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

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

コンソール

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

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

  2. 変更するファイアウォール ルールをクリックします。

  3. [編集] をクリックします。

  4. いずれかの編集可能コンポーネントをニーズに合うように変更します。

  5. [保存] をクリックします。

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 を使用して、フィールド alloweddescriptionsourceRangessourceTags、または 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 "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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: %v", 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: %v", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %v", 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\FirewallsClient;
use Google\Cloud\Compute\V1\Firewall;

/**
 * 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.
    $operation = $firewallsClient->patch($firewallRuleName, $firewallResource, $projectId);

    // 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

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:
    """
    This method will wait 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")
    return

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 ルールを確認できます。詳細については、ファイアウォール インサイトのドキュメントにあるファイアウォール ルールの詳細画面の使用をご覧ください。

コンソール

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

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

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

    [VPC ネットワーク] に移動

  2. VPC ネットワークの名前をクリックして、その詳細ページに移動します。

  3. ネットワークの詳細ページで、[ファイアウォール] タブをクリックします。

  4. 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"
	"google.golang.org/api/iterator"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// 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: %v", 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\FirewallsClient;

/**
 * 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();
    $firewallList = $firewallClient->list($projectId);

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

Python

from typing 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 ネットワーク インターフェースの詳細画面の使用をご覧ください。

コンソール

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

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

    [VM インスタンス] に移動

  2. 表示するインスタンスを見つけます。

  3. インスタンスの [その他の操作] メニュー()で、[ネットワークの詳細の表示] を選択します。

  4. インスタンスに複数のネットワーク インターフェースがある場合は、[選択したネットワーク インターフェース] フィールドに表示するネットワーク インターフェースを選択します。

  5. [ファイアウォールとルートの詳細] セクションで、[ファイアウォール] タブを選択します。

  6. vpc-firewall-rules を開きます。

  7. この表で、特定の IP アドレスとの間のトラフィックが許可されているかどうかを確認します。

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

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

コンソール

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

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 ファイアウォール ルールを削除する

コンソール

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

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 "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// 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: %v", 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: %v", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %v", 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\FirewallsClient;

/**
 * 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.
    $operation = $firewallsClient->delete($firewallRuleName, $projectId);

    // 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

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:
    """
    This method will wait 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")
    return

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 ファイアウォール ルールを構成する

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

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

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

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 ルールと類似しています。

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 ルールと類似しています。

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 ルールと類似しています。

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/24subnet2 という名前のサブネット
  • タグが webserver および内部 IP アドレス 192.168.1.2 を持つ subnet2 内の vm1 という名前のインスタンス
  • タグが database および内部 IP アドレス 192.168.1.3 を持つ subnet2 内の vm2 という名前のインスタンス
図 1. この VPC ネットワークには 2 つのサブネットがあり、それぞれに VM が含まれています。subnet2 には、ネットワーク タグが割り当てられている VM が含まれます(クリックして拡大)。

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

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

gcloud

  1. 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 は、ネットワークの名前に置き換えます。

  2. webserver でタグ付けされたインスタンス上の TCP ポート 80 にアクセスする subnet110.240.10.0/24)内のすべての IP アドレスを許可するファイアウォール ルールを作成します。

    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 接続を拒否する

gcloud

  1. すべての下り(外向き)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 は、ネットワークの名前に置き換えます。

  2. 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 トラフィックを送信できるように許可するファイアウォール ルールを作成します。

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 接続を許可する

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

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 トラフィックを許可しようと考えています。

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

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

gcloud

  1. プロジェクトの編集者またはオーナーが、my-sa-webservermy-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"
    
  2. プロジェクト オーナーが Identity and Access Management(IAM)ポリシーを設定して、ウェブサーバー開発者 web-dev@example.com にサービス アカウント my-sa-webserverserviceAccountUser のロールを割り当てます。

    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'
    
  3. プロジェクト オーナーが IAM ポリシーを設定して、データベース開発者 db-dev@example.com にサービス アカウント my-sa-databaseserviceAccountUser のロールを割り当てます。

    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'
    
  4. インスタンス管理者のロールを持つ開発者 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
    
  5. インスタンス管理者のロールを持つ開発者 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
    
  6. セキュリティ管理者は、サービス アカウント my-sa-webserver を持つ VM からの TCP トラフィックが、サービス アカウント 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.
    

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

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

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

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

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

gcloud

  1. 別の 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 は、ネットワークの名前に置き換えます。

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

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

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

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

Google Cloud コンソール の [適用] で、有効または無効を確認します。

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

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

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

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

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

次のステップ