ファイアウォール ルールの使用

このページでは、ファイアウォール ルールの処理のためのコマンドについて説明し、それらの使用例を紹介します。

始める前に

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

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

ファイアウォール ルールの作成

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

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

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

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

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

Console

  1. Google Cloud Console の [ファイアウォール] ページに移動します。
    [ファイアウォール] ページに移動
  2. [ファイアウォール ルールを作成] をクリックします。
  3. ファイアウォール ルールの [名前] を入力します。
    この名前はプロジェクトで一意にする必要があります。
  4. (省略可)ファイアウォール ルール ロギングを有効にできます。
    • [ログ] > [オン] をクリックします。
    • メタデータを省略するには、[ログの詳細] を展開して [メタデータを含める] をオフにします。
  5. ファイアウォール ルールの [ネットワーク] を指定します。
  6. ルールの [優先度] を指定します。
    数字が小さいほど、優先順位が高くなります。
  7. [トラフィックの方向] には、上りと下りのいずれかを選択します。
  8. [一致したときのアクション] には、許可と拒否のいずれかを選択します。
  9. ルールの [ターゲット] を指定します。
    • ルールをネットワーク内のすべてのインスタンスに適用する場合は All instances in the network を選択します。
    • ネットワーク(ターゲット)のタグを使用して一部のインスタンスにルールを適用する場合は Specified target tags を選択し、ルールの適用対象にするタグを [ターゲットタグ] フィールドに入力します。
    • 関連するサービス アカウントを使用して一部のインスタンスにルールを適用する場合は Specified service account を選択し、[サービス アカウントのスコープ] でサービス アカウントが現在のプロジェクトにあるか、別のプロジェクトにあるかを示します。その後、[ターゲット サービス アカウント] フィールドでサービス アカウント名を選択するか入力します。
  10. 上り(内向き)ルールの場合、[ソースフィルタ] を指定します。
    • 送信元 IPv4 の範囲で受信トラフィックをフィルタするには、[IPv4 ranges] を選択し、CIDR ブロックを [送信元 IPv4 範囲] フィールドに入力します。任意の IPv4 送信元の場合は、0.0.0.0/0 を使用します。
    • 送信元 IPv6 の範囲で受信トラフィックをフィルタするには、[IPv6 ranges] を選択し、CIDR ブロックを [送信元 IPv6 範囲] フィールドに入力します。任意の IPv6 送信元の場合は、::/0 を使用します。
    • 受信トラフィックをネットワーク タグでフィルタするには、[Source tags] を選択し、ネットワーク タグを [ソースタグ] フィールドに入力します。ソースタグ数の上限については、ネットワークごとの上限をご覧ください。ソースタグによるフィルタリングを使用できるのは、サービス アカウントによってターゲットが指定されていない場合に限られます。詳しくは、サービス アカウントによるフィルタリングとネットワーク タグによるフィルタリングをご覧ください。
    • サービス アカウントを使用して受信トラフィックをフィルタするには、[Service account] を選択し、[サービス アカウントのスコープ] でサービス アカウントが現在のプロジェクトにあるか、別のプロジェクトにあるかを示します。その後、[ソースのサービス アカウント] フィールドでサービス アカウント名を選択するか入力します。ソースのサービス アカウントでフィルタできるのは、ネットワーク タグによってターゲットが指定されていない場合に限られます。詳しくは、サービス アカウントによるフィルタリングとネットワーク タグによるフィルタリングをご覧ください。
    • 必要に応じて、[2 番目のソースフィルタ] を指定します。2 番目のソースフィルタで、メインのソースフィルタと同じフィルタ条件を使用することはできません。ソース IP の範囲は、ソースタグまたはソースサービス アカウントと組み合わせて使用できます。有効なソースセットは、ソース範囲の IP アドレスと、ネットワーク タグまたはサービス アカウントによって識別されるインスタンスを組み合わせたものです。つまり、ソース IP 範囲、またはソースタグ(またはソースサービス アカウント)のいずれかがフィルタ条件と一致する場合、そのソースは有効なソースセットに含まれています。
    • [ソースタグ] と [ソースのサービス アカウント] は併用できません。
  11. 下り(外向き)ルールの場合、[送信先フィルタ] を指定します。
    • 送信トラフィックを送信先 IPv4 範囲でフィルタするには、[IPv4 ranges] を選択し、[送信先 IPv4 範囲] フィールドに CIDR ブロックを入力します。任意の IPv4 送信先の場合は、0.0.0.0/0 を使用します。
    • 送信トラフィックを送信先 IPv6 範囲でフィルタするには、[IPv6 ranges] を選択し、[送信先 IPv6 範囲] フィールドに CIDR ブロックを入力します。任意の IPv6 送信先の場合は、::/0 を使用します。
  12. ルールを適用する [プロトコルとポート] を定義します。

    • すべてのプロトコルと宛先ポートにルールを適用する場合は、アクションに応じて Allow allDeny all のいずれかを選択します。

    • 特定のプロトコルと宛先ポートを定義します。

      • TCP のプロトコルと宛先ポートを指定する場合は [tcp] を選択します。「all」と入力するか、20-22, 80, 8080 などの宛先ポートのカンマ区切りのリストを入力します。
      • UDP のプロトコルと宛先ポートを指定するには [udp] を選択します。「all」と入力するか、67-69, 123 などの宛先ポートのカンマ区切りのリストを入力します。
      • icmpsctp などのプロトコル、またはプロトコル番号を含めるには [その他のプロトコル] を選択します。ICMPv6 にはプロトコル 58 を使用します。詳細については、プロトコルと宛先ポートをご覧ください。
  13. (省略可)ファイアウォール ルールを作成しても、その適用状態を無効に設定すれば、ルールは適用されません。[ルールを無効にする] をクリックし、[無効] を選択します。

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

gcloud

ファイアウォール ルールを作成する gcloud コマンドは次のとおりです。

gcloud compute firewall-rules create 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 フラグとともに使用する必要があります。
  • ターゲットは、次の 3 つの方法のいずれかで指定します。
    • ルールをネットワーク内のすべてのターゲットに適用する場合は、--target-tags--target-service-accounts を省略します。
    • --target-tags: ネットワーク タグを使用してターゲットを定義する場合は、このフラグを使用します。
    • --target-service-accounts: 関連するサービス アカウントを使用してターゲットを定義する場合は、このフラグを使用します。
  • 上り(内向き)ルールの場合は、ソースを指定します。
    • --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 を持たない場合であっても対象に含まれます)。
  • 下り(外向き)ルールの場合は、送信先を指定します。
    • --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

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

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

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

  • PROJECT_ID は、VPC ネットワークが配置されているプロジェクトの ID です。
  • NETWORK は、ファイアウォール ルールを作成する VPC ネットワークの名前です。
  • FIREWALL_NAME は、ファイアウォール ルールの名前です。

  • 上り(内向き)ファイアウォール ルールで、次のフィールドを使用して上り(内向き)のソース(sourceRangessourceTagssourceServiceAccounts)を指定します。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 を使用します。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 project: project, operation: 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"]
}

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

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

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

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

Console

  1. Google Cloud Console の [ファイアウォール] ページに移動します。
    [ファイアウォール] ページに移動
  2. 変更するファイアウォール ルールをクリックします。
  3. [編集] をクリックします。
  4. いずれかの編集可能コンポーネントをニーズに合うように変更します。

    [指定したプロトコルとポート] フィールドで、セミコロン区切りリストを使用して複数のプロトコル、およびプロトコルと宛先ポートのペアを指定します。IPv4 ICMP を指定するには、icmp またはプロトコル番号 1 を使用します。IPv6 ICMP を指定するには、プロトコル番号 58 を使用します。詳細については、プロトコルと宛先ポートをご覧ください。

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

gcloud

ファイアウォール ルールを更新する gcloud コマンドは次のとおりです。

gcloud compute firewall-rules update 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/FIREWALL_NAME
{
  "name": "FIREWALL_NAME",
  "network": "projects/PROJECT-ID/global/networks/NETWORK",
  ... other fields
}

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

  • PROJECT_ID は、VPC ネットワークが配置されているプロジェクトの ID です。
  • NETWORK は、ファイアウォール ルールが配置されている VPC ネットワークの名前です。
  • FIREWALL_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 [Integer] priority the new priority to be set for the rule.
def patch_firewall_priority project:, name:, priority:
  rule = {
    priority: priority
  }

  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 project: project, operation: operation.operation
end

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

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

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

Console

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

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

  1. Google Cloud Console で [VPC ネットワーク] ページに移動します。
    [VPC ネットワーク] ページに移動
  2. VPC ネットワークの名前をクリックして、その詳細ページに移動します。
  3. ネットワークの詳細ページで、[ファイアウォール ルール] タブをクリックします。

gcloud

次のコマンドを実行すると、特定のネットワーク([NETWORK-NAME])に関するファイアウォール ルールの並べ替え済みリストが出力されます。

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

API

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

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 インスタンスのネットワーク インターフェースのファイアウォール ルールを一覧表示する

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

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

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

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

  1. Google Cloud Console で、[VM インスタンス] ページに移動して、表示するインスタンスを探します。
    [VM インスタンス] ページに移動
  2. インスタンスの [その他の操作] メニュー()で、[ネットワークの詳細の表示] を選択します。
  3. インスタンスに複数のネットワーク インターフェースがある場合は、[ネットワーク インターフェースの詳細] セクションに表示するネットワーク インターフェースを選択します。
  4. [ファイアウォールとルートの詳細] セクションで、[ファイアウォール ルール] タブを選択します。
  5. この表で、特定の IP アドレスとの間のトラフィックが許可されているかどうかを確認します。

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

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

Console

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

gcloud

次のコマンドを実行すると、個別のファイアウォール ルールの情報が取得できます。[FIREWALL-NAME] の部分は、ファイアウォール ルールの名前に置き換えてください。ファイアウォール ルールの名前はプロジェクトで一意であるため、既存のルールの情報を出力する場合、ネットワークを指定する必要はありません。

gcloud compute firewall-rules describe [FIREWALL-NAME]

API

指定されたファイアウォール ルールの情報を取得します。

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

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

  • PROJECT_ID は、ファイアウォール ルールが配置されているプロジェクトの ID です。
  • FIREWALL_NAME は、説明するファイアウォール ルールの名前です。

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

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

Console

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

gcloud

次のコマンドは、ファイアウォール ルールを削除します。[FIREWALL-NAME] の部分は、削除するルールの名前に置き換えてください。

gcloud compute firewall-rules delete [FIREWALL-NAME]

API

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

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

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

  • PROJECT_ID は、ファイアウォール ルールが配置されているプロジェクトの ID です。
  • FIREWALL_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 project: project, operation: operation.operation
end

ファイアウォール ルールのモニタリング

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

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

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

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

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

gcloud

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

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

  • NAME: このファイアウォール ルールの名前。
  • NETWORK: ファイアウォール ルールが適用されるネットワークの名前。デフォルト値は default です。
  • ICMP_PROTOCOL: プロトコル名 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": "FIREWALL_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。
  • FIREWALL_NAME: ファイアウォール ルールを作成する VPC ネットワークの名前。
  • NETWORK: ファイアウォール ルールの名前。ルールを適用します。デフォルト値は default です。
  • ICMP_PROTOCOL: プロトコル名 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 NAME \
    --action=ALLOW \
    --direction=INGRESS \
    --network=NETWORK; default="default" \
    --priority=1000 \
    --rules=tcp:22 \
    --source-ranges=RANGES_OUTSIDE_VPC_NETWORK

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

  • 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": "FIREWALL_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。
  • FIREWALL_NAME: ファイアウォール ルールを作成する VPC ネットワークの名前。
  • NETWORK: ファイアウォール ルールの名前。
  • 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 NAME \
    --action=ALLOW \
    --direction=INGRESS \
    --network=NETWORK; default="default" \
    --priority=1000 \
    --rules=tcp:3389 \
    --source-ranges=RANGES_OUTSIDE_VPC_NETWORK

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

  • 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": "FIREWALL_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。
  • FIREWALL_NAME: ファイアウォール ルールを作成する VPC ネットワークの名前。
  • NETWORK: ファイアウォール ルールの名前。
  • 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 NAME \
    --action=ALLOW \
    --direction=INGRESS \
    --network=NETWORK; default="default" \
    --priority=1000 \
    --rules=ICMP_PROTOCOL \
    --source-ranges=RANGES_OUTSIDE_VPC_NETWORK

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

  • NAME: このファイアウォール ルールの名前。
  • NETWORK: ファイアウォール ルールが適用されるネットワークの名前。デフォルト値は default です。
  • ICMP_PROTOCOL: プロトコル名 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": "FIREWALL_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。
  • FIREWALL_NAME: ファイアウォール ルールを作成する VPC ネットワークの名前。
  • NETWORK: ファイアウォール ルールの名前。
  • ICMP_PROTOCOL: プロトコル名 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 ソースからのトラフィックが許可されます。

その他の構成例

次の図は、ファイアウォール構成の例を示しています。このシナリオには、以下を含めた my-network が含まれています。

  • IP 範囲が 10.240.10.0/24 のサブネット subnet1
  • IP 範囲が 192.168.1.0/24 のサブネット subnet2
  • タグが webserver および内部 IP が 192.168.1.2subnet2 内のインスタンス vm1
  • タグが database および内部 IP が 192.168.1.3subnet2 内のインスタンス vm2
ネットワーク構成例(クリックして拡大)
ネットワーク構成例(クリックして拡大)

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

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

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

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

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

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

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

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

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

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

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

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

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

テンプレート、ウェブサーバー アプリケーション my-sa-web、データベース アプリケーション「my-sa-db」を使用して自動スケーリングされる 2 つのアプリケーションを含む、以下の図のようなシナリオについて考えます。セキュリティ管理者は、my-sa-web から my-sa-db への宛先ポート 1443 の TCP フローを許可しようと考えています。

ファイアウォール ルールをサービス アカウントで使用する(クリックして拡大)
ファイアウォール ルールをサービス アカウントで使用する(クリックして拡大)

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

  1. プロジェクトの編集者またはオーナーが、my-sa-webmy-sa-db というサービス アカウントを作成します。

    gcloud iam service-accounts create my-sa-web \
        --display-name "webserver service account"
    
    gcloud iam service-accounts create my-sa-db \
        --display-name "database service account"
    
  2. プロジェクト オーナーが Identity and Access Management(IAM)ポリシーを設定して、ウェブサーバー開発者 web-dev@example.com にサービス アカウント my-sa-webserviceAccountUser のロールを割り当てます。

    gcloud iam service-accounts add-iam-policy-binding \
       my-sa-web@my-project.iam.gserviceaccount.com \
       --member='user:web-dev@example.com' \
       --role='roles/iam.serviceAccountUser'
    
  3. プロジェクト オーナーが IAM ポリシーを設定して、データベース開発者「db-dev@example.com」にサービス アカウント my-sa-dbserviceAccountUser のロールを割り当てます。

    gcloud iam service-accounts add-iam-policy-binding \
       my-sa-db@my-project.iam.gserviceaccount.com \
       --member='user:db-dev@example.com' \
       --role='roles/iam.serviceAccountUser'
    
  4. インスタンス管理者のロールを持つ開発者 web-dev@example.com が、ウェブサーバー インスタンス テンプレートを作成し、インスタンスをサービス アカウント my-sa-web として実行する権限を与えます。

    gcloud compute instance-templates create [INSTANCE_TEMPLATE_NAME]  \
        --service-account my-sa-web@my-project-123.iam.gserviceaccount.com
    
  5. インスタンス管理者のロールを持つ開発者 db-dev@example.com が、データベース インスタンス テンプレートを作成し、インスタンスをサービス アカウント my-sa-db として実行する権限を与えます。

    gcloud compute instance-templates create [INSTANCE_TEMPLATE_NAME] \
        --service-account my-sa-db@my-project-123.iam.gserviceaccount.com
    
  6. セキュリティ管理者が、サービス アカウントを使用してファイアウォール ルールを作成し、サービス アカウント my-sa-web からサービス アカウント my-sa-db への TCP:1443 トラフィックを許可します。

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

トラブルシューティング

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

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

  • 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.
    

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

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

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

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

    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 以外のネットワークとの間で接続テストを実施します。接続テストを実施してさまざまなシナリオのトラブルシューティングを行う方法については、接続テストの実施をご覧ください。

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

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

Google Cloud Console の [適用] に Enabled と表示されているか、Disabled と表示されているかを確認します。

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

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

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

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

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

次のステップ