Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Usar regras de firewall da VPC

Nesta página, descrevemos os comandos para trabalhar com regras de firewall e oferecemos alguns exemplos de como usá-los.

Antes de começar

Para saber mais sobre regras de firewall, como regras implícitas e regras geradas pelo sistema para redes padrão, consulte Regras de firewall da VPC.

Antes de configurar as regras de firewall, revise os componentes da regra de firewall para se familiarizar com os componentes de firewall usados no Google Cloud.

Criar regras de firewall

As regras de firewall são identificadas no nível da rede e se aplicam apenas à rede em que são criadas. No entanto, o nome escolhido para cada uma precisa ser único no projeto.

Uma regra de firewall pode conter intervalos IPv4 ou IPv6, mas não ambos.

Quando você cria uma regra de firewall, é possível optar por ativar a geração de registros das regras de firewall. Se você ativar a geração de registros, poderá omitir os campos de metadados para economizar custos de armazenamento. Para mais informações, consulte Usar regras de firewall.

Se você quiser especificar várias contas de serviço para o campo de conta de serviço de origem ou destino, use a Google Cloud CLI, a API ou as bibliotecas de cliente.

A rede padrão fornece regras de firewall automáticas no momento da criação. As redes personalizadas e de modo automático permitem que você crie facilmente firewalls semelhantes durante a criação da rede, caso esteja usando o console do Google Cloud. Se você estiver usando a gcloud CLI ou a API e quiser criar regras de firewall semelhantes às fornecidas pela rede padrão, consulte Configurar regras de firewall para ver casos de uso comuns.

Console

  1. No Console do Google Cloud, acesse a página Firewall.

    Acessar o Firewall

  2. Clique em Criar regra de firewall.

  3. Digite um Nome para a regra do firewall.

    O nome precisa ser exclusivo no projeto.

  4. (Opcional) É possível ativar o registro de regras de firewall:

    • Clique em Registros > Ativado.
    • Para omitir metadados, clique em Mostrar detalhes de registros e desmarque a caixa de seleção Incluir metadados.

  5. Especifique a Rede da regra de firewall.

  6. Especifique a Prioridade da regra.

    Quanto menor o número, mais alta a prioridade.

  7. Em Direção do tráfego, escolha entrada ou saída.

  8. Em Ação se houver correspondência, escolha permitir ou negar.

  9. Especifique os Destinos da regra.

    • Se você quiser que a regra se aplique a todas as instâncias na rede, escolha All instances in the network.
    • Se você quiser que a regra se aplique a determinadas instâncias por tags de rede (destino), escolha Tags de destino especificadas e, no campo Tags de destino, digite as tags às quais a regra deve ser aplicada.
    • Se você quiser que a regra se aplique a determinadas instâncias por conta de serviço associada, escolha Especificada a conta de serviço, indique se a conta de serviço está no projeto atual ou em outro em Escopo da conta de serviço e, em seguida, no campo Conta de serviço de destino, escolha ou digite o nome da conta de serviço.

  10. Para uma regra de entrada, especifique o Filtro de origem.

    • Para filtrar o tráfego de entrada por intervalos de IPv4 de origem, selecione Intervalos IPv4 e insira os blocos CIDR no campo Intervalos IPv4 de origem. Use 0.0.0.0/0 para qualquer origem IPv4.
    • Para filtrar o tráfego de entrada por intervalos IPv6 de origem, selecione Intervalos IPv6 e insira os blocos CIDR no campo Intervalos IPv6 de origem. Use ::/0 para qualquer origem IPv6.
    • Para filtrar o tráfego de entrada por tag de rede, escolha Tags de origem e digite as tags de rede no campo Tags de origem. Para ver o limite do número de tags de origem, consulte Limites por rede. A filtragem por tag de origem só estará disponível se o destino não for especificado pela conta de serviço. Para mais informações, consulte filtragem por conta de serviço versus tag de rede.
    • Para filtrar o tráfego de entrafa por conta de serviço, selecione conta de serviço, indique se a conta está no projeto atual ou em outro projeto em Escopo da conta de serviço e escolha ou digite o nome dessa conta no campo Conta de serviço de origem. A filtragem por conta de serviço de origem só estará disponível se o destino não for especificado pela tag de rede. Para mais informações, consulte filtragem por conta de serviço versus tag de rede.
    • Especifique um Segundo filtro de origem, se quiser. Os filtros de origem secundários não podem usar os mesmos critérios de filtro que o principal. Os intervalos de IP de origem podem ser usados com tags de origem ou conta de serviço de origem. O conjunto de origens efetivas é a união dos endereços IP do intervalo de origem e as instâncias identificadas pelas tags de rede ou contas de serviço. Ou seja, se o intervalo de IP de origem ou as tags de origem (ou contas de serviço de origem) corresponderem aos critérios do filtro, a origem será incluída no conjunto de origem efetivo.
    • As tags de origem e a conta de serviço de origem não podem ser usadas em conjunto.

  11. Para uma regra de saída, especifique o Filtro de destino.

    • Para filtrar o tráfego de saída por intervalos IPv4 de destino, selecione Intervalos IPv4 e insira os blocos CIDR no campo Intervalos IPv4 de destino. Use 0.0.0.0/0 para qualquer destino IPv4.
    • Para filtrar o tráfego de saída por intervalos IPv6 de destino, selecione Intervalos IPv6 e insira os blocos CIDR no campo Intervalos IPv6 de destino. Use ::/0 para qualquer destino IPv6.

  12. Defina os Protocolos e portas a que a regra se aplica:

    • Para que a regra se aplique a todos os protocolos e portas, selecione Permitir tudo ou Negar tudo, dependendo da ação.

    • Para definir protocolos e portas de destino específicos, selecione Portas e protocolos especificados:

      • Selecione TCP para incluir o protocolo TCP e as portas. Digite all ou uma lista de portas de destino delimitadas por vírgulas, como 20-22, 80, 8080.
      • Selecione UDP para incluir o protocolo UDP e as portas. Digite all ou uma lista de portas de destino delimitadas por vírgulas, como 67-69, 123.

      • Selecione Outros para incluir protocolos como icmp, sctp ou um número de protocolo. Por exemplo, use icmp ou o número do protocolo 1 para ICMP IPv4. Use o número de protocolo 58 para IPv6 ICMP.

        Para mais informações, consulte protocolos e portas de destino.

  13. (Opcional) É possível criar a regra de firewall, mas não aplicá-la, definindo seu estado de aplicação como desativada. Clique em Desativar regra e selecione Desativada.

  14. Clique em Criar.

gcloud

O comando gcloud para criar regras de firewall é:

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]

Use os parâmetros da seguinte maneira. Mais detalhes sobre cada um estão disponíveis na documentação de referência do SDK.

  • --network A rede da regra. Se omitida, a regra será criada na rede default. Se você não tiver uma rede padrão ou quiser criar a regra em uma rede específica, use este campo.
  • --priority Um valor numérico que indica a prioridade da regra. Quanto menor o número, mais alta a prioridade.
  • --direction A direção do tráfego, que pode ser ingress ou egress.
  • --action A ação na correspondência, que pode serallow ou deny. Precisa ser usado com a sinalização --rules.
  • Especifique um destino de uma das seguintes maneiras:
    • Omita --target-tags e --target-service-accounts se a regra se aplicar a todos os destinos na rede.
    • Use a sinalização --target-tags para definir destinos por tags de rede.
    • Use a sinalização --target-service-accounts para definir destinos por contas de serviço associadas.

  • Na regra de entrada, a fim de refinar ainda mais o destino, use --destination-ranges para especificar intervalos de endereços IPv4 ou IPv6 no formato CIDR. Se --destination-ranges for omitido, o destino de entrada será qualquer endereço IPv4, 0.0.0.0/0. Para mais informações, consulte Destinos das regras de entrada e Endereços IP e de destino das regras de entrada.

  • Para uma regra de entrada, especifique uma origem:

    • --source-ranges Use esta sinalização para especificar intervalos de endereços IPv4 ou IPv6 de origem no formato CIDR.
    • Se --source-ranges, source-tags e --source-service-accounts forem omitidos, a origem de entrada será qualquer endereço IPv4, 0.0.0.0/0.
    • --source-tags Use esta sinalização para especificar instâncias de origem por tags de rede. A filtragem por tag de origem só estará disponível se o destino não for especificado pela conta de serviço. Para mais informações, consulte Filtragem por conta de serviço versus tag de rede.
    • --source-ranges e --source-tags podem ser usadas juntas. Se ambos forem especificados, o conjunto de origens efetivas será a união dos endereços IP do intervalo de origem e as instâncias identificadas pelas tags de rede, mesmo se as instâncias marcadas tiverem IPs fora dos intervalos de origem.
    • --source-service-accounts Use este sinalizador para especificar instâncias pelas contas de serviço que elas usam. A filtragem por conta de serviço de origem só estará disponível se o destino não for especificado pela tag de rede. Para mais informações, consulte filtragem por conta de serviço versus tag de rede. --source-ranges e --source-service-accounts podem ser usadas juntas. Se ambos forem especificados, o conjunto de origem efetivo será a união dos endereços IP do intervalo de origem e as instâncias identificadas pelas contas de serviço de origem, mesmo que estas instâncias não tenham IPs nos intervalos de origem.

  • Na regra de saída, a fim de refinar ainda mais a origem, use --source-ranges para
    especificar intervalos de endereços IPv4 ou IPv6 no formato CIDR. Se --source-ranges for omitido, a origem de saída será qualquer endereço IPv4, 0.0.0.0/0. Para mais informações, consulte Origens das regras de saída e Endereços IP e de destino das regras de saída.

  • Para uma regra de saída, especifique um destino:

    • --destination-ranges Use esta sinalização para especificar intervalos de endereços IPv6 ou IPv6 de destino no formato CIDR.
    • Se --destination-ranges for omitido, o destino de saída será qualquer endereço IPv4, 0.0.0.0/0.

  • --rules Uma lista de protocolos e portas de destino a que a regra se aplica. Use all para tornar a regra aplicável a todos os protocolos e todas as portas. Requer a sinalização --action.

  • Por padrão, as regras de firewall são criadas e aplicadas automaticamente. No entanto, é possível alterar esse comportamento.

    • Se --disabled e --no-disabled forem omitidos, a regra de firewall será criada e aplicada.
    • --disabled Adicione este sinalizador para criar a regra de firewall, mas não para aplicá-la. Ela permanecerá desativada até que você atualize a regra de firewall para ativá-la.
    • --no-disabled Adicione esta sinalização para garantir que a regra de firewall seja aplicada.

  • --enable-logging | --no-enable-logging É possível ativar o registro de regras de firewall ao criar ou atualizar uma regra. O recurso de geração de registros de regras de firewall permite auditar, verificar e analisar os efeitos das suas regras de firewall. Consulte a geração de registros de regras de firewall para mais detalhes.

    • --logging-metadata Se você ativar a geração de registros, por padrão, a geração de registros de regras de firewall incluirá campos de base e metadados. É possível omitir campos de metadados para economizar custos de armazenamento. Para mais informações, consulte Como usar a geração de registros de regras de firewall.

API

Crie uma regra de firewall.

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a rede VPC está localizada.
  • NETWORK: o nome da rede VPC em que a regra de firewall foi criada.

  • RULE_NAME: o nome da regra de firewall.

  • Para uma regra de firewall de entrada, especifique a origem e o destino de entrada:

    • Use os campos sourceRanges, sourceTags ou sourceServiceAccounts para especificar a origem de entrada.

    • sourceRanges pode ser intervalos IPv4 ou IPv6, mas não uma combinação de ambos. Para usar o intervalo 0.0.0.0/0, não especifique nenhum campo.

    • Não é possível usar os campos sourceTags e sourceServiceAccounts juntos. No entanto, é possível usar sourceRanges com sourceTags ou sourceServiceAccounts. Se você fizer isso, a conexão precisará corresponder a um ou outro para que a regra de firewall seja aplicada.

    • Para os campos de destino, se você usar o campo sourceTags, não poderá usar o campo targetServiceAccounts. Você precisa usar o campo targetTags ou nenhum campo de destino. Da mesma forma, se você usar o campo sourceServiceAccounts, não poderá usar o campo targetTags. Se você não especificar um campo de destino, a regra será aplicada a todos os destinos na rede.

    • Use o campo destinationRanges para especificar o destino de entrada. destinationRanges pode ser um intervalo IPv4 ou IPv6, mas não uma combinação dos dois.
      Se você não especificar um destino, o Google Cloud usará 0.0.0.0/0. Para mais informações, consulte Destinos das regras de entrada e Endereços IP e de destino das regras de entrada.
      Observação: especificar intervalos de endereços IP de destino para uma regra de entrada é um recurso em fase de pré-lançamento.

  • Para uma regra de firewall de saída, especifique a origem e o destino da saída:

    • Use o campo sourceRanges para especificar a origem da saída. sourceRange pode ser intervalos IPv4 ou IPv6, mas não uma combinação de ambos.
      Se você não especificar uma origem, o Google Cloud usará 0.0.0.0/0. Para mais informações, consulte Origens das regras de saída e Endereços IP e de destino das regras de saída.
      Observação: especificar intervalos de endereços IP de origem para uma regra de saída é um recurso em fase de pré-lançamento.

    • Use o campo destinationRanges para especificar o destino. destinationRanges pode ser intervalos IPv4 ou IPv6, mas não uma combinação de ambos.
      Se você não especificar um destino, o Google Cloud usará 0.0.0.0/0. Use o campo targetTags ou targetServiceAccounts para especificar a quais destinos a regra se aplica. Se você não especificar um campo de destino, a regra será aplicada a todos os destinos na rede.

Para mais informações e descrições de cada campo, consulte o método firewalls.insert.

C#

compute/api/Compute.Samples/CreateFirewallRuleAsync.cs 

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

compute/firewall/create_firewall_rule.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

compute/cloud-client/src/main/java/compute/CreateFirewallRule.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

compute/firewall/createFirewallRule.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

compute/cloud-client/firewall/src/create_firewall_rule.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

compute/client_library/snippets/firewall/create.py 
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

google-cloud-compute-v1/samples/firewall.rb 

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

Use um recurso do Terraform para criar uma regra de firewall.

examples/basic_firewall_rule/main.tf 
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"]
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Trabalhar com uma configuração do Terraform.

Atualizar regras de firewall

É possível modificar alguns componentes de uma regra de firewall, como os protocolos e portas especificados para a condição de correspondência. Não é possível modificar o nome de uma regra de firewall, a rede, a ação, se houver correspondência, e a direção do tráfego.

Se for preciso mudar o nome, a rede ou o componente de ação ou de direção, exclua a regra e crie uma nova.

Se você quiser adicionar ou remover várias contas de serviço, use a CLI gcloud, a API ou as bibliotecas de cliente. Não é possível usar o Console do Google Cloud para especificar várias contas de serviço de destino ou de origem.

Console

  1. No Console do Google Cloud, acesse a página Firewall.

    Acessar o Firewall

  2. Clique na regra do firewall que você quer modificar.

  3. Clique em Editar.

  4. Modifique qualquer um dos componentes editáveis para atender às suas necessidades.

  5. Clique em Save.

gcloud

O comando gcloud para atualizar regras de firewall é:

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]

A descrição de cada sinalização é a mesma usada na criação de regras de firewall. Veja mais detalhes sobre cada uma na documentação de referência do SDK.

API

Use PATCH para atualizar os seguintes campos: allowed, description, sourceRanges, sourceTags ou targetTags. Use PUT ou POST para todos os outros campos.

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a rede VPC está localizada.
  • NETWORK: o nome da rede VPC em que a regra de firewall está localizada.
  • RULE_NAME: o nome da regra de firewall a ser atualizada.

Para mais informações e descrições de cada campo, consulte o método firewalls.patch ou firewalls.update.

C#

compute/api/Compute.Samples/PatchFirewallRuleAsync.cs 

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

compute/firewall/patch_firewall_priority.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

compute/cloud-client/src/main/java/compute/PatchFirewallRule.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

compute/firewall/patchFirewallPriority.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

compute/cloud-client/firewall/src/patch_firewall_priority.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

compute/client_library/snippets/firewall/patch.py 
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

google-cloud-compute-v1/samples/firewall.rb 

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

Listar regras de firewall para uma rede VPC

É possível listar todas as regras de firewall do projeto ou de uma determinada rede VPC. Para cada regra de firewall, o Google Cloud mostra detalhes como o tipo, os destinos e os filtros da regra.

Se a Geração de registros de regras de firewall for ativada, o Firewall Insights poderá fornecer insights sobre suas regras de firewall para ajudá-lo a entender e otimizar com segurança as configurações. Por exemplo, é possível ver quais regras allow não foram usadas nas últimas seis semanas. Para mais informações, consulte Como usar a tela de detalhes das regras de firewall na documentação do Firewall Insights.

Console

Para mostrar todas as regras de firewall para todas as redes do seu projeto, faça o seguinte:

Para mostrar regras de firewall em uma rede específica, siga estas etapas:

  1. No Console do Google Cloud, acesse a página Redes VPC.

    Acessar redes VPC

  2. Clique no Nome de uma rede VPC para acessar a respectiva página de detalhes.

  3. Na página de detalhes da rede, clique na guia Firewalls.

  4. Expanda vpc-firewall-rules.

gcloud

O comando a seguir produz uma lista classificada de regras de firewall para uma determinada rede.

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

Substitua NETWORK pelo nome da rede para listar as regras de firewall.

API

Lista todas as regras de firewall de uma determinada rede.

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a rede VPC está localizada.
  • NETWORK: o nome da rede VPC que contém as regras de firewall a serem listadas.

Para mais informações, consulte o método firewalls.list.

C#

compute/api/Compute.Samples/ListFirewallRulesAsync.cs 

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

compute/firewall/list_firewall_rules.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

compute/cloud-client/src/main/java/compute/ListFirewallRules.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

compute/firewall/listFirewallRules.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

compute/cloud-client/firewall/src/list_firewall_rules.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

compute/client_library/snippets/firewall/list.py 
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

google-cloud-compute-v1/samples/firewall.rb 

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

Listar regras de firewall para uma interface de rede de uma instância de VM

O Console do Google Cloud lista, para cada interface de rede, todas as regras de firewall que se aplicam à interface e às regras que estão sendo usadas por ela. As regras de firewall podem mascarar outras regras. Assim, nem todas as regras que se aplicam a uma interface são usadas por ela.

As regras de firewall são associadas e aplicadas às instâncias de VM por meio do parâmetro de destino de uma regra. Ao visualizar todas as regras aplicadas, é possível verificar se uma determinada regra é aplicada a uma interface.

Se a Geração de registros de regras de firewall for ativada, o Firewall Insights poderá fornecer insights sobre suas regras de firewall para ajudá-lo a entender e otimizar com segurança as configurações. Por exemplo, é possível ver quais regras em uma interface ocorreram nas últimas seis semanas. Para mais informações, consulte Como usar a tela de detalhes da interface de rede da VM na documentação do Firewall Insights.

Console

Para visualizar as regras de firewall que se aplicam a uma interface de rede específica de uma instância de VM:

  1. No console do Google Cloud, acesse a página Instâncias de VMs.

    Acessar instâncias de VM

  2. Encontre a instância que você quer ver.

  3. No menu mais ações () da instância, selecione Ver detalhes da rede.

  4. Se uma instância tiver várias interfaces de rede, selecione a interface de rede que será exibida no campo Interface de rede selecionada.

  5. Na seção Detalhes do firewall e das rotas, selecione a guia Firewalls.

  6. Expanda vpc-firewall-rules.

  7. Visualize a tabela para determinar se o tráfego de ou para um endereço IP específico é permitido.

Ver detalhes da regra de firewall

É possível examinar uma regra de firewall para ver o nome, a rede aplicável e os componentes dela, inclusive se a regra está ativada ou desativada.

Console

  1. Liste suas regras de firewall. É possível ver uma lista de todas as regras ou apenas aquelas em uma rede específica.
  2. Clique na regra que você quer ver.

gcloud

O comando a seguir descreve uma regra de firewall individual. Como os nomes de regras de firewall são únicos no projeto, não é preciso especificar uma rede ao descrever uma regra existente.

gcloud compute firewall-rules describe RULE_NAME

Substitua RULE_NAME pelo nome da regra de firewall.

API

Descreve uma regra de firewall específica.

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

Substitua os marcadores por valores válidos:

  • PROJECT_ID: o ID do projeto em que a regra de firewall está localizada.
  • RULE_NAME: o nome da regra de firewall a ser descrita.

Para mais informações, consulte o método firewalls.get.

Excluir regras de firewall

Console

  1. Liste suas regras de firewall. É possível ver uma lista de todas as regras ou apenas aquelas em uma rede específica.
  2. Clique na regra que você quer excluir.
  3. Clique em Excluir.
  4. Clique em Excluir novamente para confirmar.

gcloud

O comando a seguir exclui uma regra de firewall.

gcloud compute firewall-rules delete RULE_NAME

Substitua RULE_NAME pelo nome da regra a ser excluída.

API

Excluir uma regra de firewall

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a regra de firewall está localizada.
  • RULE_NAME: o nome da regra de firewall a ser excluída.

Para mais informações, consulte o método firewalls.delete.

C#

compute/api/Compute.Samples/DeleteFirewallRuleAsync.cs 

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

compute/firewall/delete_firewall_rule.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

compute/cloud-client/src/main/java/compute/DeleteFirewallRule.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

compute/firewall/deleteFirewallRule.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

compute/cloud-client/firewall/src/delete_firewall_rule.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

compute/client_library/snippets/snapshots/delete.py 
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

google-cloud-compute-v1/samples/firewall.rb 

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

Monitorar regras de firewall

É possível ativar o registro de regras de firewall para ver qual regra permitiu ou bloqueou o tráfego. Consulte Usar o registro de regras de firewall para ver instruções.

Configurar regras de firewall para casos de uso comuns

Veja nas seções a seguir exemplos de como usar a CLI gcloud e a API para recriar as regras de firewall predefinidas criadas para redes padrão. Você pode usar os exemplos para criar regras semelhantes para suas redes de modo automático e personalizado. Cada regra de firewall pode incluir intervalos de endereços IPv4 ou IPv6, mas não ambos.

Permitir conexões de entrada internas entre VMs

Os exemplos a seguir criam uma regra de firewall que permite conexões TCP, UDP e ICMP às instâncias de VM, semelhante à regra allow-internal para redes padrão:

gcloud 

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

Substitua:

  • RULE_NAME: o nome desta regra de firewall.
  • NETWORK: o nome da rede à qual se aplica essa regra de firewall. O valor padrão é default.
  • ICMP_PROTOCOL: o tipo de protocolo ICMP. Especifique o ICMPv4 usando o nome do protocolo icmp ou o número do protocolo 1. Especifique o ICMPv6 usando o protocolo número 58.

  • SUBNET_RANGES: um ou mais intervalos de endereços IP. A inclusão de um intervalo de endereços IP significa que o tráfego desse intervalo pode alcançar qualquer destino de VM na rede VPC. É possível especificar intervalos IPv4 ou IPv6 em uma determinada regra de firewall.

    Intervalos de sub-rede IPv4:

    • As redes VPC de modo automático usam intervalos de endereços IP que estão dentro de 10.128.0.0/9.
    • As redes de modo personalizado podem usar qualquer intervalo IPv4 válido. Se você não estiver usando intervalos contíguos para as sub-redes na rede VPC, talvez seja necessário especificar vários intervalos.
    • É possível usar 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 para permitir o tráfego de todos os intervalos de endereços IPv4 privados (intervalos RFC 1918).

    Intervalos de sub-rede IPv6:

    • Se você tiver atribuído um intervalo de endereços IPv6 interno à sua rede VPC, use esse intervalo como um intervalo de origem. A utilização do intervalo IPv6 interno da rede VPC significa que a regra de firewall inclui todos os intervalos de sub-rede IPv6 internos atuais e futuros. Encontre o intervalo IPv6 interno da rede VPC usando o seguinte comando:

      gcloud compute networks describe NETWORK \
  --format="flattened(internalIpv6Range)"

      Também é possível especificar intervalos de sub-rede IPv6 específicos.

    • Para permitir o tráfego dos intervalos de sub-rede IPv6 externos de sub-redes de pilha dupla, você precisa especificar o intervalo de endereços IPv6 de cada sub-rede que quer incluir.

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a rede VPC está localizada;
  • RULE_NAME: o nome da regra de firewall.
  • NETWORK: o nome da rede VPC em que a regra de firewall foi criada. O valor padrão é default.
  • ICMP_PROTOCOL: o tipo de protocolo ICMP. Especifique o ICMPv4 usando o nome do protocolo icmp ou o número do protocolo 1. Especifique o ICMPv6 usando o protocolo número 58.

  • INTERNAL_SOURCE_RANGES: um ou mais intervalos de IP. Para permitir o tráfego interno em todas as sub-redes nas redes VPC, especifique os intervalos de endereços IP usados na rede VPC. É possível especificar intervalos IPv4 ou IPv6 em uma determinada regra de firewall.

    Intervalos de sub-rede IPv4:

    • As redes VPC de modo automático usam intervalos de endereços IP que estão dentro de 10.128.0.0/9.
    • As redes de modo personalizado podem usar qualquer intervalo IPv4 válido. Se você não estiver usando intervalos contíguos para as sub-redes na rede VPC, talvez seja necessário especificar vários intervalos.
    • É possível usar 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 para permitir o tráfego de todos os intervalos de endereços IPv4 privados (intervalos RFC 1918).

    Intervalos de sub-rede IPv6:

    • Se você tiver atribuído um intervalo de endereços IPv6 interno à sua rede VPC, use esse intervalo como um intervalo de origem. A utilização do intervalo IPv6 interno da rede VPC significa que a regra de firewall inclui todos os intervalos de sub-rede IPv6 internos atuais e futuros. Encontre o intervalo IPv6 interno da rede VPC usando o seguinte comando:

      gcloud compute networks describe NETWORK \
  --format="flattened(internalIpv6Range)"

      Também é possível especificar intervalos de sub-rede IPv6 específicos.

    • Para permitir o tráfego dos intervalos de sub-rede IPv6 externos de sub-redes de pilha dupla, você precisa especificar o intervalo de endereços IPv6 de cada sub-rede que quer incluir.

Permitir conexões SSH de entrada a VMs

Os exemplos a seguir criam uma regra de firewall que permite conexões SSH às instâncias de VM, semelhante à regra allow-ssh para redes padrão:

gcloud 

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

Substitua:

  • RULE_NAME: o nome desta regra de firewall.
  • NETWORK: o nome da rede à qual se aplica essa regra de firewall. O valor padrão é default.

  • RANGES_OUTSIDE_VPC_NETWORK: um ou mais intervalos de endereços IP. É possível especificar intervalos IPv4 ou IPv6 em uma determinada regra de firewall. Como prática recomendada, especifique os intervalos de endereços IP específicos dos quais é preciso permitir o acesso, em vez de todos as origens IPv4 ou IPv6.

    • A inclusão de 35.235.240.0/20 nos intervalos de origem permitirá conexões SSH usando o encaminhamento de TCP do Identity-Aware Proxy (IAP) se todos os outros pré-requisitos forem atendidos. Para mais informações, consulte Como usar o IAP para encaminhamento de TCP.
    • O uso de 0.0.0.0/0 como um intervalo de origem permite o tráfego de todas as origens IPv4, incluindo origens fora do Google Cloud.
    • O uso de ::/0 como um intervalo de origem permite o tráfego de todas as origens IPv6, incluindo origens fora do Google Cloud.

API 

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a rede VPC está localizada;
  • RULE_NAME: o nome da regra de firewall.
  • NETWORK: o nome da rede VPC em que a regra de firewall foi criada.

  • RANGES_OUTSIDE_VPC_NETWORK: um ou mais intervalos de endereços IP. É possível especificar intervalos IPv4 ou IPv6 em uma determinada regra de firewall. Como prática recomendada, especifique os intervalos de endereços IP específicos dos quais é preciso permitir o acesso, em vez de todos as origens IPv4 ou IPv6.

    • A inclusão de 35.235.240.0/20 nos intervalos de origem permitirá conexões SSH usando o encaminhamento de TCP do Identity-Aware Proxy (IAP) se todos os outros pré-requisitos forem atendidos. Para mais informações, consulte Como usar o IAP para encaminhamento de TCP.
    • O uso de 0.0.0.0/0 como um intervalo de origem permite o tráfego de todas as origens IPv4, incluindo origens fora do Google Cloud.
    • O uso de ::/0 como um intervalo de origem permite o tráfego de todas as origens IPv6, incluindo origens fora do Google Cloud.

Permitir conexões RDP de entrada a VMs

Os exemplos a seguir criam uma regra de firewall que permite conexões do protocolo da área de trabalho remota (RDP, na sigla em inglês) da Microcoft às instâncias de VM, semelhante à regra allow-rdp para redes padrão:

gcloud 

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

Substitua:

  • RULE_NAME: o nome desta regra de firewall.
  • NETWORK: o nome da rede à qual se aplica essa regra de firewall. O valor padrão é default.

  • RANGES_OUTSIDE_VPC_NETWORK: um ou mais intervalos de endereços IP. É possível especificar intervalos IPv4 ou IPv6 em uma determinada regra de firewall. Como prática recomendada, especifique os intervalos de endereços IP específicos dos quais é preciso permitir o acesso, em vez de todos as origens IPv4 ou IPv6.

    • A inclusão de 35.235.240.0/20 nos intervalos de origem permitirá conexões RDP usando o encaminhamento de TCP do Identity-Aware Proxy (IAP) se todos os outros pré-requisitos forem atendidos. Para mais informações, consulte Como usar o IAP para encaminhamento de TCP.
    • O uso de 0.0.0.0/0 como um intervalo de origem permite o tráfego de todas as origens IPv4, incluindo origens fora do Google Cloud.
    • O uso de ::/0 como um intervalo de origem permite o tráfego de todas as origens IPv6, incluindo origens fora do Google Cloud.

API 

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a rede VPC está localizada;
  • RULE_NAME: o nome da regra de firewall.
  • NETWORK: o nome da rede VPC em que a regra de firewall foi criada.

  • RANGES_OUTSIDE_VPC_NETWORK: um ou mais intervalos de endereços IP. É possível especificar intervalos IPv4 ou IPv6 em uma determinada regra de firewall. Como prática recomendada, especifique os intervalos de endereços IP específicos dos quais é preciso permitir o acesso, em vez de todos as origens IPv4 ou IPv6.

    • A inclusão de 35.235.240.0/20 nos intervalos de origem permitirá conexões RDP usando o encaminhamento de TCP do Identity-Aware Proxy (IAP) se todos os outros pré-requisitos forem atendidos. Para mais informações, consulte Como usar o IAP para encaminhamento de TCP.
    • O uso de 0.0.0.0/0 como um intervalo de origem permite o tráfego de todas as origens IPv4, incluindo origens fora do Google Cloud.
    • O uso de ::/0 como um intervalo de origem permite o tráfego de todas as origens IPv6, incluindo origens fora do Google Cloud.

Permitir conexões ICMP de entrada a VMs

Os exemplos a seguir criam uma regra de firewall que permite conexões SSH às instâncias de VM, semelhante à regra allow-icmp para redes padrão:

gcloud 

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

Substitua:

  • RULE_NAME: o nome da regra de firewall.
  • NETWORK: o nome da rede à qual se aplica essa regra de firewall. O valor padrão é default.
  • ICMP_PROTOCOL: o tipo de protocolo ICMP. Especifique o ICMPv4 usando o nome do protocolo icmp ou o número do protocolo 1. Especifique o ICMPv6 usando o protocolo número 58.

  • RANGES_OUTSIDE_VPC_NETWORK: um ou mais intervalos de endereços IP. É possível especificar intervalos IPv4 ou IPv6 em uma determinada regra de firewall. Como prática recomendada, especifique os intervalos de endereços IP específicos dos quais é preciso permitir o acesso, em vez de todos as origens IPv4 ou IPv6.

    • O uso de 0.0.0.0/0 como um intervalo de origem permite o tráfego de todas as origens IPv4, incluindo origens fora do Google Cloud.
    • O uso de ::/0 como um intervalo de origem permite o tráfego de todas as origens IPv6, incluindo origens fora do Google Cloud.

API 

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a rede VPC está localizada;
  • RULE_NAME: o nome da regra de firewall.
  • NETWORK: o nome da rede VPC em que a regra de firewall foi criada.
  • ICMP_PROTOCOL: o tipo de protocolo ICMP a ser usado. Especifique o ICMPv4 usando o nome do protocolo icmp ou o número do protocolo 1. Especifique o ICMPv6 usando o protocolo número 58.

  • RANGES_OUTSIDE_VPC_NETWORK: um ou mais intervalos de endereços IP. É possível especificar intervalos IPv4 ou IPv6 em uma determinada regra de firewall. Como prática recomendada, especifique os intervalos de endereços IP específicos dos quais é preciso permitir o acesso, em vez de todos as origens IPv4 ou IPv6.

    • O uso de 0.0.0.0/0 como um intervalo de origem permite o tráfego de todas as origens IPv4, incluindo origens fora do Google Cloud.
    • O uso de ::/0 como um intervalo de origem permite o tráfego de todas as origens IPv6, incluindo origens fora do Google Cloud.

Outros exemplos de configuração

O diagrama abaixo demonstra um exemplo de configuração de firewall. O cenário envolve um my-network que contém o seguinte:

  • Uma sub-rede subnet1 com intervalo de IP 10.240.10.0/24
  • Uma sub-rede subnet2 com intervalo de IP 192.168.1.0/24
  • Instância vm1 em subnet2 com a tag webserver e o IP interno 192.168.1.2
  • Instância vm2 em subnet2 com a tag database e o IP interno 192.168.1.3
Exemplo de configuração de rede (clique para ampliar)
Exemplo de configuração de rede (clique para ampliar)

Exemplo 1: negar todas as conexões TCP de entrada, exceto as de subnet1 para a porta 80

Este exemplo cria um conjunto de regras de firewall que negam todas as conexões TCP de entrada, exceto as conexões destinadas à porta 80 da subnet1.

gcloud

  1. Crie uma regra de firewall para negar todo o tráfego TCP de entrada para instâncias marcadas com webserver.

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

    Substitua NETWORK_NAME pelo nome da rede.

  2. Crie uma regra de firewall para permitir que todos os IPs em subnet1 (10.240.10.0/24) acessem a porta TCP 80 em instâncias marcadas com a tag webserver.

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

    Substitua NETWORK_NAME pelo nome da rede.

Exemplo 2: negar todas as conexões TCP de saída, exceto para a porta 80 da vm1

gcloud

  1. Crie uma regra de firewall para negar todo o tráfego TCP de saída.

    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

    Substitua NETWORK_NAME pelo nome da rede.

  2. Crie uma regra de firewall para permitir o tráfego TCP destinado à porta vm1 80.

    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

    Substitua NETWORK_NAME pelo nome da rede.

Exemplo 3: permitir a saída de conexões TCP para a porta 443 de um host externo

Crie uma regra de firewall que permita que instâncias marcadas com webserver enviem o tráfego TCP de saída para a porta 443 de um endereço IP externo de amostra, 192.0.2.5.

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

Substitua NETWORK_NAME pelo nome da rede.

Exemplo 4: permitir conexões SSH de vm2 para vm1

Crie uma regra de firewall que permita o tráfego SSH de instâncias com a tag database (vm2) para chegar a instâncias com a tag webserver (vm1).

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

Substitua NETWORK_NAME pelo nome da rede.

Exemplo 5: permitir TCP:1443 do servidor web ao banco de dados usando as contas de serviço

Para mais informações sobre contas de serviço e papéis, consulte Conceder papéis a contas de serviço.

Considere o cenário no diagrama abaixo, no qual há dois aplicativos com escalonamento automático feito por meio de modelos, um aplicativo de servidor da Web my-sa-web e um aplicativo de banco de dados "my-sa-db". Um administrador de segurança quer permitir que os fluxos TCP acessem a porta 1443 de my-sa-web para my-sa-db.

Como usar regras de firewall com contas de serviço (clique para ampliar)
Como usar regras de firewall com contas de serviço (clique para ampliar)

As etapas de configuração, incluindo a criação de contas de serviço, são as seguintes:

gcloud

  1. Um projeto EDITOR ou PROPRIETÁRIO do projeto cria as contas de serviço my-sa-web e my-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. Um PROPRIETÁRIO do projeto atribui ao desenvolvedor do servidor da Web web-dev@example.com um papel serviceAccountUser para a conta de serviço my-sa-web definindo uma política de gerenciamento de identidade e acesso (IAM, na sigla em inglês).

    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. Um PROPRIETÁRIO do projeto atribui ao desenvolvedor do banco de dados "db-dev@exemplo.com" um papel serviceAccountUser para a conta de serviço my-sa-db definindo uma política do IAM.

    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. O desenvolvedor web-dev@example.com, que tem o papel de administrador da instância, cria um modelo de instância de servidor da Web e autoriza a execução das instâncias como conta de serviço my-sa-web.

    gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME] \
   --service-account my-sa-web@my-project-123.iam.gserviceaccount.com

  5. O desenvolvedor db-dev@example.com, que tem o papel de administrador de instância, cria o modelo de instância do banco de dados e autoriza a execução das instâncias como conta de serviço my-sa-db.

    gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
  --service-account my-sa-db@my-project-123.iam.gserviceaccount.com

  6. O administrador de segurança cria as regras de firewall usando contas de serviço para permitir o tráfego TCP:1443 da conta de serviço my-sa-web para a conta de serviço my-sa-db.

    gcloud compute firewall-rules create RULE_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

Solução de problemas

Mensagens de erro ao criar ou atualizar uma regra de firewall

Talvez você verá uma das seguintes mensagens de erro:

  • Should not specify destination range for ingress direction.

    Os intervalos de destino não são parâmetros válidos para regras de firewall de entrada. Presume-se que as regras de firewall sejam regras de entrada, a menos que a direção de egress seja expressamente especificada. Se você criar uma regra que não especifique uma direção, ela será criada como uma regra de entrada, que não permite um intervalo de destino. Além disso, os intervalos de origem não são parâmetros válidos para as regras de saída.

  • Firewall direction cannot be changed once created.

    Não é possível mudar a direção de uma regra de firewall existente. Crie uma nova regra com os parâmetros corretos e exclua a antiga.

  • Firewall traffic control action cannot be changed once created.

    Não é possível alterar a ação de uma regra de firewall existente. Crie uma nova regra com os parâmetros corretos e exclua a antiga.

  • Service accounts must be valid RFC 822 email addresses.A conta de serviço especificada na regra de firewall precisa ser um endereço de e-mail formatado conforme a norma 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. Não é possível especificar contas de serviço e tags na mesma regra.

    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.

Erro de muitos firewalls grandes

Talvez você veja a seguinte mensagem de erro: Google Compute Engine: The network contains too many large firewalls.

Para manter a segurança e o desempenho, há um limite na complexidade e no número de regras de firewall que podem ser implementadas em uma rede VPC. Se você encontrar esse erro, peça à equipe de gerenciamento de conta para simplificar ou consolidar as regras de firewall.

Não é possível conectar-se à instância de VM

Para se conectar a uma instância de VM, verifique suas regras de firewall.

gcloud

  1. Para iniciar a conexão de outra instância de VM, liste as regras de firewall de saída para essa instância.

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

    Substitua NETWORK_NAME pelo nome da rede.

  2. Verifique se o IP de destino é negado por alguma regra de saída. A regra com a prioridade mais alta (número de prioridade mais baixa) substitui regras de prioridade mais baixa. Para duas regras com a mesma prioridade, opta-se pela regra de negação.

  3. Verifique a regra de firewall de entrada para a rede que contém a instância de VM de destino.

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

    Substitua NETWORK_NAME pelo nome da rede.

    Exemplo de saída. A saída dependerá da lista de regras de firewall.

    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. Também é possível executar testes de conectividade de/para instâncias de VM em uma rede VPC para outra rede VPC ou rede de nuvem que não seja do Google para solucionar problemas se o tráfego estiver sendo descartado por qualquer regra de firewall de entrada ou saída. Para saber mais sobre como executar os testes de conectividade para solucionar problemas em vários casos, veja Como executar Testes de conectividade

Minha regra de firewall está ativada ou desativada?

Para ver se uma regra de firewall está ativada ou desativada, visualize os detalhes das regras de firewall.

No Console do Google Cloud, procure Ativado ou Desativado em Aplicação.

Na saída da CLI gcloud, procure o campo disabled. Se o valor é disabled:false, a regra está ativada e sendo aplicada. Se o valor é disabled: true, a regra está desativada.

Qual regra é aplicada em uma instância de VM?

Depois da criação de uma regra, é possível verificar se ela está sendo aplicada corretamente em uma instância específica. Para mais informações, consulte Como listar regras de firewall para uma interface de rede de uma instância de VM.

As regras de firewall com tags de origem não são aplicadas imediatamente

As regras de firewall de entrada que usam tags de origem podem levar algum tempo para serem propagadas. Para mais detalhes, consulte considerações relacionadas a tags de origem para regras de firewall de entrada.

A seguir