Usar reglas de cortafuegos de VPC

En esta página se describen los comandos para trabajar con reglas de cortafuegos de nube privada virtual (VPC) y se ofrecen algunos ejemplos de cómo usarlos. Las reglas de cortafuegos de VPC te permiten permitir o denegar el tráfico hacia o desde instancias de máquina virtual (VM) en una red de VPC en función del número de puerto, la etiqueta o el protocolo.

Antes de empezar

Para obtener más información sobre las reglas de cortafuegos de VPC, como las reglas implícitas y las reglas generadas por el sistema para las redes predeterminadas, consulta el artículo Reglas de cortafuegos de VPC.

Antes de configurar reglas de cortafuegos, consulta los componentes de las reglas de cortafuegos para familiarizarte con ellos tal como se usan en Google Cloud.

Crear reglas de cortafuegos de VPC

Las reglas de cortafuegos de VPC se definen a nivel de red y solo se aplican a la red en la que se crean. Sin embargo, el nombre que elijas para cada una de ellas debe ser único en el proyecto.

Una regla de cortafuegos puede contener intervalos IPv4 o IPv6, pero no ambos.

Cuando creas una regla de cortafuegos, puedes habilitar la función Almacenamiento de registros de reglas de cortafuegos. Si habilitas el registro, puedes omitir campos de metadatos para ahorrar costes de almacenamiento. Para obtener más información, consulta Usar el almacenamiento de registros de reglas de cortafuegos.

Si quieres especificar varias cuentas de servicio en el campo de cuenta de servicio de destino o de origen, usa la CLI de Google Cloud, la API o las bibliotecas de cliente.

La red predeterminada proporciona reglas de cortafuegos automáticas en el momento de la creación. Las redes en modo automático y personalizado te permiten crear cortafuegos similares fácilmente durante la creación de la red si utilizas la Google Cloud consola. Si usas la CLI de gcloud o la API y quieres crear reglas de cortafuegos similares a las que proporciona la red predeterminada, consulta Configurar reglas de cortafuegos para casos prácticos habituales.

Consola

  1. En la Google Cloud consola, ve a la página Políticas de cortafuegos.

    Ir a Políticas de cortafuegos

  2. Haz clic en Crear regla de cortafuegos.

  3. Introduce un nombre para la regla de cortafuegos.

    Este nombre debe ser único en el proyecto.

  4. (Opcional) Puedes habilitar el registro de reglas de cortafuegos:

    • Haz clic en Registros > Activado.
    • Para omitir los metadatos, haga clic en Mostrar detalles de los registros y, a continuación, desmarque la casilla Incluir metadatos.

  5. Especifica la red de la regla de cortafuegos.

  6. Especifica la prioridad de la regla.

    Cuanto menor sea el número, mayor será la prioridad.

  7. En Dirección del tráfico, elige entrada o salida.

  8. En Acción tras coincidencia, elige permitir o denegar.

  9. Especifica los objetivos de la regla.

    • Si quieres que la regla se aplique a todas las instancias de la red, elige Todas las instancias de la red.
    • Si quieres que la regla se aplique a instancias concretas por etiquetas de red (de destino), elige Etiquetas de destino especificadas y, a continuación, en el campo Etiquetas de destino, escribe las etiquetas a las que se debe aplicar la regla.
    • Si quieres que la regla se aplique a instancias concretas por cuenta de servicio asociada, elige Cuenta de servicio especificada, indica si la cuenta de servicio está en el proyecto actual o en otro en Ámbito de la cuenta de servicio y, a continuación, en el campo Cuenta de servicio de destino, elige o escribe el nombre de la cuenta de servicio.

  10. En el caso de una regla de entrada, especifique el filtro de origen:

    • Para filtrar el tráfico entrante por intervalos de IPv4 de origen, seleccione Intervalos de IPv4 y, a continuación, introduzca los bloques CIDR en el campo Intervalos de IPv4 de origen. Usa 0.0.0.0/0 para cualquier fuente IPv4.
    • Para filtrar el tráfico entrante por intervalos de IPv6 de origen, selecciona Intervalos de IPv6 y, a continuación, introduce los bloques CIDR en el campo Intervalos de IPv6 de origen. Usa ::/0 para cualquier fuente IPv6.
    • Para filtrar el tráfico entrante por etiqueta de red, elija Etiquetas de origen y, a continuación, escriba las etiquetas de red en el campo Etiquetas de origen. Para consultar el límite del número de etiquetas de origen, consulta los límites por red. Solo se puede filtrar por etiqueta de origen si el destino no se especifica por cuenta de servicio. Para obtener más información, consulta la sección sobre filtrar por cuenta de servicio o por etiqueta de red.
    • Para filtrar el tráfico entrante por cuenta de servicio, elige Cuenta de servicio, indica si la cuenta de servicio está en el proyecto actual o en otro en Ámbito de la cuenta de servicio y, a continuación, elige o escribe el nombre de la cuenta de servicio en el campo Cuenta de servicio de origen. Solo se puede filtrar por cuenta de servicio de origen si la etiqueta de red no especifica el destino. Para obtener más información, consulta la sección sobre filtrar por cuenta de servicio o por etiqueta de red.
    • Si quieres, especifica un filtro de origen secundario. Los filtros de fuentes secundarias no pueden usar los mismos criterios de filtro que los de la fuente principal. Los intervalos de IPs de origen se pueden usar junto con las etiquetas de origen o la cuenta de servicio de origen. El conjunto de fuentes efectivo es la unión de las direcciones IP del intervalo de origen y las instancias identificadas por etiquetas de red o cuentas de servicio. Es decir, si el intervalo de IPs de origen o las etiquetas de origen (o las cuentas de servicio de origen) coinciden con los criterios del filtro, el origen se incluye en el conjunto de orígenes efectivo.
    • No se pueden usar etiquetas de origen y cuentas de servicio de origen al mismo tiempo.

  11. En el caso de una regla de entrada, especifique el Filtro de destino:

    • Para filtrar el tráfico entrante por intervalos de IPv4 de destino, seleccione Intervalos de IPv4 e introduzca los bloques CIDR en el campo Intervalos de IPv4 de destino. Usa 0.0.0.0/0 para cualquier destino IPv4.
    • Para filtrar el tráfico entrante por intervalos de IPv6 de destino, selecciona Intervalos de IPv6 e introduce los bloques CIDR en el campo Intervalos de IPv6 de destino. Usa ::/0 para cualquier destino IPv6. Para obtener más información, consulta Destino de las reglas de entrada.

  12. En el caso de una regla de salida, especifica el Filtro de destino:

    • Para filtrar el tráfico saliente por intervalos de IPv4 de destino, seleccione Intervalos de IPv4 e introduzca los bloques CIDR en el campo Intervalos de IPv4 de destino. Usa 0.0.0.0/0 para cualquier destino IPv4.
    • Para filtrar el tráfico saliente por intervalos de IPv6 de destino, seleccione Intervalos de IPv6 e introduzca los bloques CIDR en el campo Intervalos de IPv6 de destino. Usa ::/0 para cualquier destino IPv6.

  13. En el caso de una regla de salida, especifique el filtro de origen:

    • Para filtrar el tráfico saliente por intervalos de IPv4 de origen, selecciona Intervalos de IPv4 e introduce los bloques CIDR en el campo Intervalos de IPv4 de origen. Usa 0.0.0.0/0 para cualquier fuente IPv4.
    • Para filtrar el tráfico saliente por intervalos de IPv6 de origen, selecciona Intervalos de IPv6 e introduce los bloques CIDR en el campo Intervalos de IPv6 de origen. Usa ::/0 para cualquier destino IPv6. Para obtener más información, consulta Origen de las reglas de salida.

  14. Define los protocolos y puertos a los que se aplica la regla:

    • Para que la regla se aplique a todos los protocolos y puertos de destino, selecciona Permitir todos o Rechazar todos, según la acción.

    • Para definir protocolos y puertos de destino específicos, selecciona Protocolos y puertos especificados:

      • Selecciona TCP para incluir el protocolo TCP y los puertos de destino. Introduce all o una lista de puertos de destino separados por comas, como 20-22, 80, 8080.
      • Selecciona UDP para incluir el protocolo UDP y los puertos de destino. Introduce all o una lista de puertos de destino separados por comas, como 67-69, 123.

      • Selecciona Otro para incluir protocolos como icmp, sctp o un número de protocolo. Por ejemplo, usa icmp o el número de protocolo 1 para ICMP de IPv4. Usa el número de protocolo 58 para ICMP de IPv6.

        Para obtener más información, consulta protocolos y puertos de destino.

  15. (Opcional) Puedes crear la regla de cortafuegos, pero no aplicarla. Para ello, define su estado de aplicación como inhabilitado. Haz clic en Inhabilitar regla y, a continuación, selecciona Inhabilitada.

  16. Haz clic en Crear.

gcloud

Para crear una regla de cortafuegos de VPC, usa el comando gcloud compute firewall-rules create:

gcloud compute firewall-rules create RULE_NAME \
    [--network NETWORK; default="default"] \
    [--priority PRIORITY;default=1000] \
    [--direction (ingress|egress|in|out); default="ingress"] \
    [--action (deny | allow )] \
    [--target-tags TAG[,TAG,...]] \
    [--target-service-accounts=IAM_SERVICE_ACCOUNT[,IAM_SERVICE_ACCOUNT,...]] \
    [--source-ranges CIDR_RANGE[,CIDR_RANGE,...]] \
    [--source-tags TAG,TAG,] \
    [--source-service-accounts=IAM_SERVICE_ACCOUNT[,IAM_SERVICE_ACCOUNT,...]] \
    [--destination-ranges CIDR_RANGE[,CIDR_RANGE,...]] \
    [--rules (PROTOCOL[:PORT[-PORT]],[PROTOCOL[:PORT[-PORT]],...]] | all ) \
    [--disabled | --no-disabled] \
    [--enable-logging | --no-enable-logging] \
    [--logging-metadata LOGGING_METADATA]

Usa los parámetros de la siguiente manera. Para obtener más información sobre cada uno de ellos, consulta la documentación de referencia del SDK.

  • --network La red de la regla. Si se omite, la regla se crea en la red default. Si no tiene una red predeterminada o quiere crear la regla en una red específica, debe usar este campo.
  • --priority Valor numérico que indica la prioridad de la regla. Cuanto menor sea el número, mayor será la prioridad.
  • --direction La dirección del tráfico, ya sea INGRESS o EGRESS.
  • --action La acción tras coincidencia, ya sea allow o deny. Se debe usar con la marca --rules.
  • Especifique un objetivo de una de las siguientes formas:
    • Omita --target-tags y --target-service-accounts si la regla se debe aplicar a todos los objetivos de la red.
    • Usa la marca --target-tags para definir objetivos por etiquetas de red.
    • Usa la marca --target-service-accounts para definir objetivos por cuentas de servicio asociadas.

  • Para la regla de entrada, si quieres acotar aún más el destino, usa --destination-ranges para especificar intervalos de direcciones IPv4 o IPv6 en formato CIDR. Si se omite --destination-ranges, el destino de entrada es cualquier dirección IPv4, 0.0.0.0/0. Para obtener más información, consulta Destinos de las reglas de entrada y Direcciones IP y de destino de las reglas de entrada.

  • En el caso de una regla de entrada, especifica un origen:

    • --source-ranges Usa esta marca para especificar intervalos de direcciones IPv4 o IPv6 de origen en formato CIDR.
    • Si se omiten --source-ranges, source-tags y --source-service-accounts, el origen de entrada es cualquier dirección IPv4, 0.0.0.0/0.
    • --source-tags Usa esta marca para especificar las instancias de origen por etiquetas de red. El filtro por etiqueta de origen solo está disponible si el destino no se especifica mediante una cuenta de servicio. Para obtener más información, consulta la sección sobre filtrar por cuenta de servicio o etiqueta de red.
    • --source-ranges y --source-tags se pueden usar juntos. Si se especifican ambos, el conjunto de origen efectivo es la unión de las direcciones IP del intervalo de origen y las instancias identificadas por etiquetas de red, aunque las instancias etiquetadas no tengan IPs en los intervalos de origen.
    • --source-service-accounts Usa esta marca para especificar instancias por las cuentas de servicio que usan. El filtro por cuenta de servicio de origen solo está disponible si el destino no se especifica mediante una etiqueta de red. Para obtener más información, consulta Filtrar por cuenta de servicio o por etiqueta de red. --source-ranges y --source-service-accounts se pueden usar juntos. Si se especifican ambos, el conjunto de orígenes efectivo es la unión de las direcciones IP del intervalo de origen y las instancias identificadas por las cuentas de servicio de origen, aunque las instancias identificadas por las cuentas de servicio de origen no tengan IPs en los intervalos de origen.

  • En la regla de salida, para acotar aún más la fuente, usa --source-ranges para especificar intervalos de direcciones IPv4 o IPv6 en formato CIDR. Si se omite --source-ranges, la fuente de salida es cualquier dirección IPv4, 0.0.0.0/0. Para obtener más información, consulta Fuentes de las reglas de salida y Direcciones IP y de destino de las reglas de salida.

  • En el caso de una regla de salida, especifica un destino:

    • --destination-ranges Usa esta marca para especificar intervalos de direcciones IPv4 o IPv6 de destino en formato CIDR.
    • Si se omite --destination-ranges, el destino de salida será cualquier dirección IPv4, 0.0.0.0/0.

  • --rules Una lista de protocolos y puertos de destino a los que se aplica la regla. Usa all para que la regla se aplique a todos los protocolos y a todos los puertos de destino. Requiere la marca --action.

  • De forma predeterminada, las reglas de cortafuegos se crean y se aplican automáticamente. Sin embargo, puede cambiar este comportamiento.

    • Si se omiten --disabled y --no-disabled, se crea y se aplica la regla de firewall.
    • --disabled Añade esta marca para crear la regla de cortafuegos, pero no aplicarla. La regla de cortafuegos permanecerá inhabilitada hasta que la actualices para habilitarla.
    • --no-disabled Añade esta marca para asegurarte de que se aplica la regla de cortafuegos.

  • --enable-logging | --no-enable-logging Puedes habilitar el registro de reglas de cortafuegos cuando crees o actualices una regla. El almacenamiento de registros de reglas de cortafuegos te permite auditar, verificar y analizar los efectos de tus reglas de cortafuegos. Consulta Registro de reglas de cortafuegos para obtener más información.

    • --logging-metadata Si habilitas el registro, de forma predeterminada, la función Almacenamiento de registros de reglas de cortafuegos incluye campos básicos y de metadatos. Puedes omitir campos de metadatos para ahorrar costes de almacenamiento. Para obtener más información, consulta Usar el registro de reglas de cortafuegos.

Terraform

Para crear una regla de cortafuegos, puede usar un google_compute_firewallrecurso.

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

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

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

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

API

Crea una regla de cortafuegos de VPC.

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

Haz los cambios siguientes:

  • PROJECT_ID: el ID del proyecto en el que se encuentra la red de VPC.
  • NETWORK: el nombre de la red de VPC en la que se crea la regla de cortafuegos.

  • RULE_NAME: el nombre de la regla de cortafuegos.

  • En el caso de una regla de cortafuegos de entrada, especifica el origen y el destino de la entrada:

    • Usa los campos sourceRanges, sourceTags o sourceServiceAccounts para especificar la fuente de entrada.

    • sourceRanges pueden ser intervalos IPv4 o IPv6, pero no una combinación de ambos. Para usar el intervalo 0.0.0.0/0, no especifique ningún campo.

    • No puedes usar los campos sourceTags y sourceServiceAccounts al mismo tiempo. Sin embargo, puedes usar sourceRanges con sourceTags o sourceServiceAccounts. Si lo haces, la conexión solo tiene que coincidir con una de las dos para que se aplique la regla de cortafuegos.

    • En los campos de destino, si usa el campo sourceTags, no podrá usar el campo targetServiceAccounts. Debe usar el campo targetTags o ningún campo de destino. Del mismo modo, si usas el campo sourceServiceAccounts, no puedes usar el campo targetTags. Si no especifica un campo de destino, la regla se aplica a todos los destinos de la red.

    • Utiliza el campo destinationRanges para especificar el destino de entrada. destinationRanges pueden ser intervalos IPv4 o IPv6, pero no una combinación de ambos.
      Si no especificas un destino, Google Cloud usa 0.0.0.0/0. Para obtener más información, consulta Destinos de las reglas de entrada y Direcciones IP y de destino de las reglas de entrada.

  • En el caso de una regla de cortafuegos de salida, especifica el origen y el destino de la salida:

    • Utiliza el campo sourceRanges para especificar la fuente de salida. sourceRange pueden ser intervalos IPv4 o IPv6, pero no una combinación de ambos.
      Si no especificas ninguna fuente, Google Cloud usa 0.0.0.0/0. Para obtener más información, consulta las secciones Fuentes de las reglas de salida y Direcciones IP y de destino de las reglas de salida.

    • Usa el campo destinationRanges para especificar el destino. destinationRanges pueden ser intervalos IPv4 o IPv6, pero no una combinación de ambos.
      Si no especifica un destino, Google Cloud usa 0.0.0.0/0. Usa el campo targetTags o targetServiceAccounts para especificar a qué objetivos se aplica la regla. Si no especifica un campo de destino, la regla se aplica a todos los destinos de la red.

Para obtener más información y descripciones de cada campo, consulta el método firewalls.insert.

C# 


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class CreateFirewallRuleAsyncSample
{
    public async Task CreateFirewallRuleAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string firewallRuleName = "my-test-firewall-rule",
        // Name of the network the rule will be applied to. Some available name formats:
        // projects/{project_id}/global/networks/{network}
        // global/networks/{network}
        string networkName = "global/networks/default")
    {
        Firewall firewallRule = new Firewall
        {
            Name = firewallRuleName,
            Network = networkName,
            Direction = ComputeEnumConstants.Firewall.Direction.Ingress,
            Allowed =
            {
                new Allowed
                {
                    Ports = { "80", "443" },
                    IPProtocol = "tcp"
                }
            },
            TargetTags = { "web" },
            Description = "Allows TCP traffic on port 80 and 443 from anywhere."
        };

        // Note that the default value of priority for the firewall API is 1000.
        // If you check the value of firewallRule.Priority at this point it
        // will be equal to 0, however it is not treated as "set" by the library, and thus
        // the default will be applied to the new rule. If you want to create a rule that
        // has priority == 0, you'll need to explicitly set it: firewallRule.Priority = 0.
        // You can use the firewallRule.HasPriority property to check if the priority has been set.
        // You can use the firewallRule.ClearPriority() method to unset the priority.

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        FirewallsClient client = await FirewallsClient.CreateAsync();

        // Create the firewall rule in the specified project.
        var firewallRuleCreation = await client.InsertAsync(projectId, firewallRule);

        // Wait for the operation to complete using client-side polling.
        await firewallRuleCreation.PollUntilCompletedAsync();
    }
}

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createFirewallRule creates a firewall rule allowing for incoming HTTP and HTTPS access from the entire Internet.
func createFirewallRule(w io.Writer, projectID, firewallRuleName, networkName string) error {
	// projectID := "your_project_id"
	// firewallRuleName := "europe-central2-b"
	// networkName := "global/networks/default"

	ctx := context.Background()
	firewallsClient, err := compute.NewFirewallsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer firewallsClient.Close()

	firewallRule := &computepb.Firewall{
		Allowed: []*computepb.Allowed{
			{
				IPProtocol: proto.String("tcp"),
				Ports:      []string{"80", "443"},
			},
		},
		Direction: proto.String(computepb.Firewall_INGRESS.String()),
		Name:      &firewallRuleName,
		TargetTags: []string{
			"web",
		},
		Network:     &networkName,
		Description: proto.String("Allowing TCP traffic on port 80 and 443 from Internet."),
	}

	// Note that the default value of priority for the firewall API is 1000.
	// If you check the value of `firewallRule.GetPriority()` at this point it
	// will be equal to 0, however it is not treated as "set" by the library and thus
	// the default will be applied to the new rule. If you want to create a rule that
	// has priority == 0, you need to explicitly set it so:

	// firewallRule.Priority = proto.Int32(0)

	req := &computepb.InsertFirewallRequest{
		Project:          projectID,
		FirewallResource: firewallRule,
	}

	op, err := firewallsClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create firewall rule: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Firewall rule created\n")

	return nil
}

Java 


import com.google.cloud.compute.v1.Allowed;
import com.google.cloud.compute.v1.Firewall;
import com.google.cloud.compute.v1.Firewall.Direction;
import com.google.cloud.compute.v1.FirewallsClient;
import com.google.cloud.compute.v1.InsertFirewallRequest;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateFirewallRule {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample
    /* project: project ID or project number of the Cloud project you want to use.
       firewallRuleName: name of the rule that is created.
       network: name of the network the rule will be applied to. Available name formats:
        * https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
        * projects/{project_id}/global/networks/{network}
        * global/networks/{network} */
    String project = "your-project-id";
    String firewallRuleName = "firewall-rule-name-" + UUID.randomUUID();
    String network = "global/networks/default";

    // The rule will be created with default priority of 1000.
    createFirewall(project, firewallRuleName, network);
  }

  // Creates a simple firewall rule allowing for incoming HTTP and 
  // HTTPS access from the entire Internet.
  public static void createFirewall(String project, String firewallRuleName, String network)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `firewallsClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (FirewallsClient firewallsClient = FirewallsClient.create()) {

      // The below firewall rule is created in the default network.
      Firewall firewallRule = Firewall.newBuilder()
          .setName(firewallRuleName)
          .setDirection(Direction.INGRESS.toString())
          .addAllowed(
              Allowed.newBuilder().addPorts("80").addPorts("443").setIPProtocol("tcp").build())
          .addSourceRanges("0.0.0.0/0")
          .setNetwork(network)
          .addTargetTags("web")
          .setDescription("Allowing TCP traffic on port 80 and 443 from Internet.")
          .build();

      /* Note that the default value of priority for the firewall API is 1000.
         If you check the value of `firewallRule.getPriority()` at this point it
         will be equal to 0, however it is not treated as "set" by the library and thus
         the default will be applied to the new rule. If you want to create a rule that
         has priority == 0, you'll need to explicitly set it so: setPriority(0) */

      InsertFirewallRequest insertFirewallRequest = InsertFirewallRequest.newBuilder()
          .setFirewallResource(firewallRule)
          .setProject(project).build();

      firewallsClient.insertAsync(insertFirewallRequest).get(3, TimeUnit.MINUTES);

      System.out.println("Firewall rule created successfully -> " + firewallRuleName);
    }
  }
}

Node.js 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const firewallRuleName = 'YOUR_FIREWALL_RULE_NAME'
// const networkName = 'global/networks/default'

const compute = require('@google-cloud/compute');
const computeProtos = compute.protos.google.cloud.compute.v1;

async function createFirewallRule() {
  const firewallsClient = new compute.FirewallsClient();
  const operationsClient = new compute.GlobalOperationsClient();

  const firewallRule = new computeProtos.Firewall();
  firewallRule.name = firewallRuleName;
  firewallRule.direction = 'INGRESS';
  firewallRule.allowed = [
    {
      IPProtocol: 'tcp',
      ports: ['80', '443'],
    },
  ];
  firewallRule.targetTags = ['web'];
  firewallRule.network = networkName;
  firewallRule.description =
    'Allowing TCP traffic on port 80 and 443 from Internet.';

  // Note that the default value of priority for the firewall API is 1000.
  // If you check the value of `firewallRule.priority` at this point it
  // will be equal to null, however it is not treated as "set" by the library and thus
  // the default will be applied to the new rule. If you want to create a rule that
  // has priority == 0, you need to explicitly set it so:

  // firewallRule.priority = 0

  const [response] = await firewallsClient.insert({
    project: projectId,
    firewallResource: firewallRule,
  });
  let operation = response.latestResponse;

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
    });
  }

  console.log('Firewall rule created');
}

createFirewallRule();

PHP 

use Google\Cloud\Compute\V1\Allowed;
use Google\Cloud\Compute\V1\Client\FirewallsClient;
use Google\Cloud\Compute\V1\Enums\Firewall\Direction;

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

/**
 * Creates a simple firewall rule allowing incoming HTTP and HTTPS access from the entire internet.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to create a rule for.
 * @param string $firewallRuleName Name of the rule that is created.
 * @param string $network Name of the network the rule will be applied to. Available name formats:
 *                        https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
 *                        projects/{project_id}/global/networks/{network}
 *                        global/networks/{network}
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */

function create_firewall_rule(string $projectId, string $firewallRuleName, string $network = 'global/networks/default')
{
    $firewallsClient = new FirewallsClient();
    $allowedPorts = (new Allowed())
      ->setIPProtocol('tcp')
      ->setPorts(['80', '443']);
    $firewallResource = (new Firewall())
      ->setName($firewallRuleName)
      ->setDirection(Direction::INGRESS)
      ->setAllowed([$allowedPorts])
      ->setSourceRanges(['0.0.0.0/0'])
      ->setTargetTags(['web'])
      ->setNetwork($network)
      ->setDescription('Allowing TCP traffic on ports 80 and 443 from Internet.');

    /**
    * Note that the default value of priority for the firewall API is 1000.
    * If you check the value of its priority at this point it will be
    * equal to 0, however it is not treated as "set" by the library and thus
    * the default will be applied to the new rule. If you want to create a rule
    * that has priority == 0, you need to explicitly set it so:
    *
    *   $firewallResource->setPriority(0);
    */

    //Create the firewall rule using Firewalls Client.
    $request = (new InsertFirewallRequest())
        ->setFirewallResource($firewallResource)
        ->setProject($projectId);
    $operation = $firewallsClient->insert($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Created rule %s.' . PHP_EOL, $firewallRuleName);
    } else {
        $error = $operation->getError();
        printf('Firewall rule creation failed: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python 

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_firewall_rule(
    project_id: str, firewall_rule_name: str, network: str = "global/networks/default"
) -> compute_v1.Firewall:
    """
    Creates a simple firewall rule allowing for incoming HTTP and HTTPS access from the entire Internet.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        firewall_rule_name: name of the rule that is created.
        network: name of the network the rule will be applied to. Available name formats:
            * https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
            * projects/{project_id}/global/networks/{network}
            * global/networks/{network}

    Returns:
        A Firewall object.
    """
    firewall_rule = compute_v1.Firewall()
    firewall_rule.name = firewall_rule_name
    firewall_rule.direction = "INGRESS"

    allowed_ports = compute_v1.Allowed()
    allowed_ports.I_p_protocol = "tcp"
    allowed_ports.ports = ["80", "443"]

    firewall_rule.allowed = [allowed_ports]
    firewall_rule.source_ranges = ["0.0.0.0/0"]
    firewall_rule.network = network
    firewall_rule.description = "Allowing TCP traffic on port 80 and 443 from Internet."

    firewall_rule.target_tags = ["web"]

    # Note that the default value of priority for the firewall API is 1000.
    # If you check the value of `firewall_rule.priority` at this point it
    # will be equal to 0, however it is not treated as "set" by the library and thus
    # the default will be applied to the new rule. If you want to create a rule that
    # has priority == 0, you need to explicitly set it so:
    # TODO: Uncomment to set the priority to 0
    # firewall_rule.priority = 0

    firewall_client = compute_v1.FirewallsClient()
    operation = firewall_client.insert(
        project=project_id, firewall_resource=firewall_rule
    )

    wait_for_extended_operation(operation, "firewall rule creation")

    return firewall_client.get(project=project_id, firewall=firewall_rule_name)

Ruby 


require "google/cloud/compute/v1"

# Creates a simple firewall rule allowing for incoming HTTP and HTTPS access from the entire Internet.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] name: name of the rule that is created.
# @param network: name of the network the rule will be applied to. Available name formats:
#         * https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
#         * projects/{project_id}/global/networks/{network}
#         * global/networks/{network}
def create_firewall_rule project:, name:, network: "global/networks/default"
  rule = {
    name: name,
    direction: "INGRESS",
    allowed: [{
      I_p_protocol: "tcp",
      ports: ["80", "443"]
    }],
    source_ranges: ["0.0.0.0/0"],
    network: network,
    description: "Allowing TCP traffic on port 80 and 443 from Internet.",
    target_tags: ["web"]
  }

  # Note that the default value of priority for the firewall API is 1000.
  # If you want to create a rule that has priority == 0, you need to explicitly set it:
  #   rule[:priority] = 0
  # Use `rule.has_key? :priority` to check if the priority has been set.
  # Use `rule.delete :priority` method to unset the priority.

  request = {
    firewall_resource: rule,
    project: project
  }

  client = ::Google::Cloud::Compute::V1::Firewalls::Rest::Client.new
  operation = client.insert request

  wait_until_done operation: operation
end

Actualizar reglas de cortafuegos de VPC

Puedes modificar algunos componentes de una regla de cortafuegos de VPC, como los protocolos y los puertos de destino especificados en la condición de coincidencia. No puedes modificar el nombre, la red, la acción al coincidir ni la dirección del tráfico de una regla de cortafuegos.

Si necesitas cambiar el nombre, la red o el componente de acción o dirección, debes eliminar la regla y crear una nueva.

Si quieres añadir o quitar varias cuentas de servicio, usa la CLI de gcloud, la API o las bibliotecas de cliente. No puedes usar la consola Google Cloud para especificar varias cuentas de servicio de destino o de origen.

Consola

  1. En la Google Cloud consola, ve a la página Políticas de cortafuegos.

    Ir a Políticas de cortafuegos

  2. Haz clic en la regla de firewall que quieras modificar.

  3. Haz clic en Editar.

  4. Modifica los componentes editables para adaptarlos a tus necesidades.

  5. Haz clic en Guardar.

gcloud

Para actualizar las reglas de cortafuegos de VPC, usa el comando gcloud compute firewall-rules update:

gcloud compute firewall-rules update RULE_NAME \
    [--priority=PRIORITY] \
    [--description=DESCRIPTION] \
    [--target-tags=TAG,...] \
    [--target-service-accounts=IAM_SERVICE_ACCOUNT,_] \
    [--source-ranges=CIDR_RANGE,...] \
    [--source-tags=TAG,...] \
    [--source-service-accounts=IAM_SERVICE_ACCOUNT,_] \
    [--destination-ranges=CIDR_RANGE,...] \
    [--rules=[PROTOCOL[:PORT[-PORT]],…]] \
    [--disabled | --no-disabled] \
    [--enable-logging | --no-enable-logging]

Las descripciones de cada marca son las mismas que las de la creación de reglas de firewall, y puede consultar más detalles sobre cada una de ellas en la documentación de referencia del SDK.

API

Usa PATCH para actualizar los siguientes campos: allowed, description, sourceRanges, sourceTags o targetTags. Usa PUT o POST para el resto de los 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
}

Haz los cambios siguientes:

  • PROJECT_ID: el ID del proyecto en el que se encuentra la red de VPC.
  • NETWORK: el nombre de la red de VPC en la que se encuentra la regla de cortafuegos.
  • RULE_NAME: nombre de la regla de cortafuegos que se va a actualizar.

Para obtener más información y descripciones de cada campo, consulta el método firewalls.patch o firewalls.update.

C# 


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class PatchFirewallRuleAsyncSample
{
    public async Task PatchFirewallRuleAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string firewallRuleName = "my-test-firewall-rule",
        int newPriority = 10)
    {
        // The patch operation doesn't require the full definition of a Firewall object.
        // It will only update the values that were set in it,
        // in this case it will only change the priority.
        Firewall firewallRule = new Firewall
        {
            Priority = newPriority
        };

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        FirewallsClient client = await FirewallsClient.CreateAsync();

        // Patch the firewall rule in the specified project.
        var firewallRulePatching = await client.PatchAsync(projectId, firewallRuleName, firewallRule);

        // Wait for the operation to complete using client-side polling.
        await firewallRulePatching.PollUntilCompletedAsync();
    }
}

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// patchFirewallPriority modifies the priority of a given firewall rule.
func patchFirewallPriority(w io.Writer, projectID, firewallRuleName string, priority int32) error {
	// projectID := "your_project_id"
	// firewallRuleName := "europe-central2-b"
	// priority := 10

	ctx := context.Background()
	firewallsClient, err := compute.NewFirewallsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer firewallsClient.Close()

	firewallRule := &computepb.Firewall{
		Priority: proto.Int32(priority),
	}

	req := &computepb.PatchFirewallRequest{
		Project:          projectID,
		Firewall:         firewallRuleName,
		FirewallResource: firewallRule,
	}

	// The patch operation doesn't require the full definition of a Firewall interface. It will only update
	// the values that were set in it, in this case it will only change the priority.
	op, err := firewallsClient.Patch(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to patch firewall rule: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Firewall rule updated\n")

	return nil
}

Java 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.Firewall;
import com.google.cloud.compute.v1.FirewallsClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.PatchFirewallRequest;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class PatchFirewallRule {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample
    // project: project ID or project number of the Cloud project you want to use.
    // firewallRuleName: name of the rule you want to modify.
    // priority: the new priority to be set for the rule.
    String project = "your-project-id";
    String firewallRuleName = "firewall-rule-name-" + UUID.randomUUID();
    int priority = 10;

    patchFirewallPriority(project, firewallRuleName, priority);
  }

  // Modifies the priority of a given firewall rule.
  public static void patchFirewallPriority(String project, String firewallRuleName, int priority)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `firewallsClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (FirewallsClient firewallsClient = FirewallsClient.create()) {

      /* The patch operation doesn't require the full definition of a Firewall object. It will only 
         update the values that were set in it, in this case it will only change the priority. */
      Firewall firewall = Firewall.newBuilder()
          .setPriority(priority).build();

      PatchFirewallRequest patchFirewallRequest = PatchFirewallRequest.newBuilder()
          .setProject(project)
          .setFirewall(firewallRuleName)
          .setFirewallResource(firewall).build();

      OperationFuture<Operation, Operation> operation = firewallsClient.patchAsync(
          patchFirewallRequest);
      operation.get(3, TimeUnit.MINUTES);
      System.out.println("Firewall Patch applied successfully ! ");
    }
  }
}

Node.js 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const firewallRuleName = 'FIREWALL_RULE_NAME';
// const priority = 10;

const compute = require('@google-cloud/compute');
const computeProtos = compute.protos.google.cloud.compute.v1;

async function patchFirewallPriority() {
  const firewallsClient = new compute.FirewallsClient();
  const operationsClient = new compute.GlobalOperationsClient();

  const firewallRule = new computeProtos.Firewall();
  firewallRule.priority = priority;

  // The patch operation doesn't require the full definition of a Firewall object. It will only update
  // the values that were set in it, in this case it will only change the priority.
  const [response] = await firewallsClient.patch({
    project: projectId,
    firewall: firewallRuleName,
    firewallResource: firewallRule,
  });
  let operation = response.latestResponse;

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
    });
  }

  console.log('Firewall rule updated');
}

patchFirewallPriority();

PHP 

use Google\Cloud\Compute\V1\Client\FirewallsClient;
use Google\Cloud\Compute\V1\Firewall;
use Google\Cloud\Compute\V1\PatchFirewallRequest;

/**
 * Modifies the priority of a given firewall rule.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to patch a rule from.
 * @param string $firewallRuleName Name of the rule that you want to modify.
 * @param int $priority The new priority to be set for the rule.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function patch_firewall_priority(string $projectId, string $firewallRuleName, int $priority)
{
    $firewallsClient = new FirewallsClient();
    $firewallResource = (new Firewall())->setPriority($priority);

    // The patch operation doesn't require the full definition of a Firewall object. It will only update
    // the values that were set in it, in this case it will only change the priority.
    $request = (new PatchFirewallRequest())
        ->setFirewall($firewallRuleName)
        ->setFirewallResource($firewallResource)
        ->setProject($projectId);
    $operation = $firewallsClient->patch($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Patched %s priority to %d.' . PHP_EOL, $firewallRuleName, $priority);
    } else {
        $error = $operation->getError();
        printf('Patching failed: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python 

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def patch_firewall_priority(
    project_id: str, firewall_rule_name: str, priority: int
) -> None:
    """
    Modifies the priority of a given firewall rule.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        firewall_rule_name: name of the rule you want to modify.
        priority: the new priority to be set for the rule.
    """
    firewall_rule = compute_v1.Firewall()
    firewall_rule.priority = priority

    # The patch operation doesn't require the full definition of a Firewall object. It will only update
    # the values that were set in it, in this case it will only change the priority.
    firewall_client = compute_v1.FirewallsClient()
    operation = firewall_client.patch(
        project=project_id, firewall=firewall_rule_name, firewall_resource=firewall_rule
    )

    wait_for_extended_operation(operation, "firewall rule patching")

Ruby 


require "google/cloud/compute/v1"

# Modifies the priority of a given firewall rule.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] name name of the rule you want to modify.
# @param [Google::Protobuf::RepeatedField] allowed the repeated instances of the Allowed field in the rule.
#         Compute errors out if allowed is empty.
# @param [Integer] priority the new priority to be set for the rule.
def patch_firewall_priority project:, name:, allowed:, priority:
  allowed_arr = allowed.map do |instance|
    {
      I_p_protocol: instance.I_p_protocol,
      ports: instance.ports.to_a
    }
  end.to_a

  rule = {
    priority: priority,
    allowed: allowed_arr
  }

  request = {
    project: project,
    firewall: name,
    firewall_resource: rule
  }

  # The patch operation doesn't require the full definition of a Firewall object. It will only update
  # the values that were set in it, in this case it will only change the priority.
  client = ::Google::Cloud::Compute::V1::Firewalls::Rest::Client.new
  operation = client.patch request

  wait_until_done operation: operation
end

Lista de reglas de cortafuegos de VPC de una red de VPC

Puedes enumerar todas las reglas de cortafuegos de VPC de tu proyecto o de una red de VPC concreta. En cada regla de cortafuegos,Google Cloud muestra detalles como el tipo, los destinos y los filtros de la regla.

Si habilitas Registro de reglas de cortafuegos, Firewall Insights puede proporcionarte información valiosa sobre tus reglas de cortafuegos para ayudarte a comprender mejor sus configuraciones y optimizarlas de forma segura. Por ejemplo, puedes ver qué reglas de allow no se han usado en las últimas seis semanas. Para obtener más información, consulta la sección Usar la pantalla de detalles de las reglas de cortafuegos de la documentación de Firewall Insights.

Consola

Para mostrar todas las reglas de cortafuegos de VPC de todas las redes de tu proyecto, sigue estos pasos:

Para mostrar las reglas de cortafuegos de VPC de una red concreta, sigue estos pasos:

  1. En la Google Cloud consola, ve a la página Redes de VPC.

    Ir a redes de VPC

  2. Haga clic en el nombre de una red de VPC para ir a su página de detalles.

  3. En la página de detalles de la red, haga clic en la pestaña Firewalls (Cortafuegos).

  4. Expande vpc-firewall-rules.

gcloud

Para generar una lista ordenada de reglas de cortafuegos de VPC de una red determinada, usa el comando gcloud compute firewall-rules list:

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

Sustituye NETWORK por el nombre de la red en la que quieras mostrar las reglas de cortafuegos.

API

Muestra todas las reglas de cortafuegos de VPC de una red determinada.

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

Haz los cambios siguientes:

  • PROJECT_ID: el ID del proyecto en el que se encuentra la red de VPC.
  • NETWORK: el nombre de la red de VPC que contiene las reglas de cortafuegos que se van a enumerar.

Para obtener más información, consulta el método firewalls.list.

C# 


using Google.Cloud.Compute.V1;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class ListFirewallRulesAsyncSample
{
    public async Task ListFirewallRulesAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id")
    {
        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        FirewallsClient client = await FirewallsClient.CreateAsync();

        // Make the request to list all firewall rules.
        await foreach (var firewallRule in client.ListAsync(projectId))
        {
            // The result is a Firewall sequence that you can iterate over.
            Console.WriteLine($"Firewal Rule: {firewallRule.Name}");
        }
    }
}

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/api/iterator"
)

// listFirewallRules prints the list of firewall names and their descriptions in specified project
func listFirewallRules(w io.Writer, projectID string) error {
	// projectID := "your_project_id"

	ctx := context.Background()
	firewallsClient, err := compute.NewFirewallsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer firewallsClient.Close()

	req := &computepb.ListFirewallsRequest{
		Project: projectID,
	}

	it := firewallsClient.List(ctx, req)
	for {
		firewallRule, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s: %s\n", firewallRule.GetName(), firewallRule.GetDescription())
	}

	return nil
}

Java 


import com.google.cloud.compute.v1.Firewall;
import com.google.cloud.compute.v1.FirewallsClient;
import com.google.cloud.compute.v1.FirewallsClient.ListPagedResponse;
import java.io.IOException;

public class ListFirewallRules {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample
    // project: project ID or project number of the Cloud project you want to use.
    String project = "your-project-id";
    listFirewallRules(project);
  }

  // Return a list of all the firewall rules in specified project.
  // Also prints the list of firewall names and their descriptions.
  public static ListPagedResponse listFirewallRules(String project)
      throws IOException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `firewallsClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (FirewallsClient firewallsClient = FirewallsClient.create()) {
      ListPagedResponse firewallResponse = firewallsClient.list(project);
      for (Firewall firewall : firewallResponse.iterateAll()) {
        System.out.println(firewall.getName());
      }
      return firewallResponse;
    }
  }
}

Node.js 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';

const compute = require('@google-cloud/compute');

async function listFirewallRules() {
  const firewallsClient = new compute.FirewallsClient();

  const [firewallRules] = await firewallsClient.list({
    project: projectId,
  });

  for (const rule of firewallRules) {
    console.log(` - ${rule.name}: ${rule.description}`);
  }
}

listFirewallRules();

PHP 

use Google\Cloud\Compute\V1\Client\FirewallsClient;
use Google\Cloud\Compute\V1\ListFirewallsRequest;

/**
 * Return a list of all the firewall rules in specified project. Also prints the
 * list of firewall names and their descriptions.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to list rules from.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 */
function list_firewall_rules(string $projectId)
{
    // List all firewall rules defined for the project using Firewalls Client.
    $firewallClient = new FirewallsClient();
    $request = (new ListFirewallsRequest())
        ->setProject($projectId);
    $firewallList = $firewallClient->list($request);

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

Python 

from __future__ import annotations

from collections.abc import Iterable

from google.cloud import compute_v1


def list_firewall_rules(project_id: str) -> Iterable[compute_v1.Firewall]:
    """
    Return a list of all the firewall rules in specified project. Also prints the
    list of firewall names and their descriptions.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.

    Returns:
        A flat list of all firewall rules defined for given project.
    """
    firewall_client = compute_v1.FirewallsClient()
    firewalls_list = firewall_client.list(project=project_id)

    for firewall in firewalls_list:
        print(f" - {firewall.name}: {firewall.description}")

    return firewalls_list

Ruby 


require "google/cloud/compute/v1"

# Return a list of all the firewall rules in specified project. Also prints the
# list of firewall names and their descriptions.
#
# @param [String] project project ID or project number of the project you want to use.
# @return [Array<::Google::Cloud::Compute::V1::Firewall>]
#     A list of all firewall rules defined for the given project.
def list_firewall_rules project:
  client = ::Google::Cloud::Compute::V1::Firewalls::Rest::Client.new
  firewalls = client.list project: project

  firewall_list = []
  firewalls.each do |firewall|
    puts " - #{firewall.name}: #{firewall.description}"
    firewall_list << firewall
  end

  firewall_list
end

Lista las reglas de cortafuegos de VPC de una interfaz de red de una instancia de VM

En cada interfaz de red, la consola muestra todas las reglas de cortafuegos de VPC que se aplican a la interfaz y las reglas que utiliza la interfaz. Google Cloud Las reglas de cortafuegos pueden enmascarar otras reglas, por lo que es posible que la interfaz no utilice todas las reglas que se aplican a ella.

Las reglas de cortafuegos se asocian y se aplican a las instancias de VM a través del parámetro target de una regla. Si ves todas las reglas aplicadas, puedes comprobar si una regla concreta se está aplicando a una interfaz.

Si habilitas Registro de reglas de cortafuegos, Firewall Insights puede proporcionarte información valiosa sobre tus reglas de cortafuegos para ayudarte a comprender mejor sus configuraciones y optimizarlas de forma segura. Por ejemplo, puedes ver qué reglas de una interfaz han tenido coincidencias en las últimas seis semanas. Para obtener más información, consulta la sección Usar la pantalla de detalles de la interfaz de red de la VM de la documentación de Estadísticas de cortafuegos.

Consola

Para ver las reglas de VPC que se aplican a una interfaz de red específica de una instancia de VM, sigue estos pasos:

  1. En la consola de Google Cloud , ve a la página Instancias de VM.

    Ir a instancias de VM

  2. Busca la instancia que quieras ver.

  3. En el menú Más acciones () de la instancia, selecciona Ver detalles de la red.

  4. Si una instancia tiene varias interfaces de red, selecciona la interfaz de red que quieras ver en el campo Interfaz de red seleccionada.

  5. En la sección Detalles de cortafuegos y rutas, seleccione la pestaña Cortafuegos.

  6. Expande vpc-firewall-rules.

  7. Consulte la tabla para determinar si se permite el tráfico hacia o desde una dirección IP específica.

Ver los detalles de una regla de cortafuegos de VPC

Puedes inspeccionar una regla de cortafuegos de VPC para ver su nombre, la red aplicable y los componentes, incluido si la regla está habilitada o inhabilitada.

Consola

  1. Lista de tus reglas de cortafuegos. Puede ver una lista de todas las reglas o solo las de una red concreta.
  2. Haz clic en la regla para verla.

gcloud

El siguiente comando describe una regla de firewall de VPC concreta. Como los nombres de las reglas de cortafuegos son únicos en el proyecto, no tienes que especificar una red al describir una regla de cortafuegos.

gcloud compute firewall-rules describe RULE_NAME

Sustituye RULE_NAME por el nombre de la regla de firewall.

API

Describe una regla de cortafuegos de VPC determinada.

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

Sustituye los marcadores de posición por valores válidos:

  • PROJECT_ID: el ID del proyecto en el que se encuentra la regla de firewall.
  • RULE_NAME: nombre de la regla de cortafuegos que se va a describir.

Para obtener más información, consulta el método firewalls.get.

Eliminar reglas de cortafuegos de VPC

Consola

  1. Lista de tus reglas de cortafuegos de VPC. Puede ver una lista de todas las reglas o solo las de una red concreta.
  2. Haz clic en la regla que quieras eliminar.
  3. Haz clic en Eliminar.
  4. Haz clic en Eliminar de nuevo para confirmar la acción.

gcloud

Para eliminar una regla de cortafuegos de VPC, usa el comando gcloud compute firewall-rules delete:

gcloud compute firewall-rules delete RULE_NAME

Sustituye RULE_NAME por el nombre de la regla que quieras eliminar.

API

Elimina una regla de cortafuegos de VPC.

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

Haz los cambios siguientes:

  • PROJECT_ID: el ID del proyecto en el que se encuentra la regla de cortafuegos.
  • RULE_NAME: el nombre de la regla de cortafuegos que se va a eliminar.

Para obtener más información, consulta el método firewalls.delete.

C# 


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class DeleteFirewallRuleAsyncSample
{
    public async Task DeleteFirewallRuleAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string firewallRuleName = "my-test-firewall-rule")
    {

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        FirewallsClient client = await FirewallsClient.CreateAsync();

        // Make the request to delete the firewall rule.
        var firewallRuleDeletion = await client.DeleteAsync(projectId, firewallRuleName);

        // Wait for the operation to complete using client-side polling.
        await firewallRuleDeletion.PollUntilCompletedAsync();
    }
}

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// deleteFirewallRule deletes a firewall rule from the project.
func deleteFirewallRule(w io.Writer, projectID, firewallRuleName string) error {
	// projectID := "your_project_id"
	// firewallRuleName := "europe-central2-b"

	ctx := context.Background()
	firewallsClient, err := compute.NewFirewallsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer firewallsClient.Close()

	req := &computepb.DeleteFirewallRequest{
		Project:  projectID,
		Firewall: firewallRuleName,
	}

	op, err := firewallsClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete firewall rule: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Firewall rule deleted\n")

	return nil
}

Java 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.FirewallsClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DeleteFirewallRule {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample
    // project: project ID or project number of the Cloud project you want to use.
    // firewallRuleName: name of the firewall rule you want to delete.
    String project = "your-project-id";
    String firewallRuleName = "firewall-rule-name-" + UUID.randomUUID();
    deleteFirewallRule(project, firewallRuleName);
  }


  // Deletes a firewall rule from the project.
  public static void deleteFirewallRule(String project, String firewallRuleName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `firewallsClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (FirewallsClient firewallsClient = FirewallsClient.create()) {

      OperationFuture<Operation, Operation> operation = firewallsClient.deleteAsync(project,
          firewallRuleName);
      operation.get(3, TimeUnit.MINUTES);

      System.out.println("Deleted firewall rule -> " + firewallRuleName);
    }
  }
}

Node.js 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const firewallRuleName = 'FIREWALL_RULE_NAME';

const compute = require('@google-cloud/compute');

async function deleteFirewallRule() {
  const firewallsClient = new compute.FirewallsClient();
  const operationsClient = new compute.GlobalOperationsClient();

  const [response] = await firewallsClient.delete({
    project: projectId,
    firewall: firewallRuleName,
  });
  let operation = response.latestResponse;

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
    });
  }

  console.log('Firewall rule deleted');
}

deleteFirewallRule();

PHP 

use Google\Cloud\Compute\V1\Client\FirewallsClient;
use Google\Cloud\Compute\V1\DeleteFirewallRequest;

/**
 * Delete a firewall rule from the specified project.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to delete a rule for.
 * @param string $firewallRuleName Name of the rule that is deleted.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function delete_firewall_rule(string $projectId, string $firewallRuleName)
{
    $firewallsClient = new FirewallsClient();

    // Delete the firewall rule using Firewalls Client.
    $request = (new DeleteFirewallRequest())
        ->setFirewall($firewallRuleName)
        ->setProject($projectId);
    $operation = $firewallsClient->delete($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Rule %s deleted successfully!' . PHP_EOL, $firewallRuleName);
    } else {
        $error = $operation->getError();
        printf('Failed to delete firewall rule: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python 

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def delete_firewall_rule(project_id: str, firewall_rule_name: str) -> None:
    """
    Deletes a firewall rule from the project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        firewall_rule_name: name of the firewall rule you want to delete.
    """
    firewall_client = compute_v1.FirewallsClient()
    operation = firewall_client.delete(project=project_id, firewall=firewall_rule_name)

    wait_for_extended_operation(operation, "firewall rule deletion")

Ruby 


require "google/cloud/compute/v1"

# Deletes a firewall rule from the project.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] name name of the firewall rule you want to delete.
def delete_firewall_rule project:, name:
  client = ::Google::Cloud::Compute::V1::Firewalls::Rest::Client.new
  operation = client.delete project: project, firewall: name

  wait_until_done operation: operation
end

Monitorizar reglas de cortafuegos de VPC

Puede habilitar el registro de las reglas de cortafuegos de VPC para ver qué regla ha permitido o bloqueado el tráfico. Consulta las instrucciones en Usar el almacenamiento de registros de reglas de cortafuegos.

Configurar reglas de cortafuegos de VPC para casos prácticos habituales

En las siguientes secciones se ofrecen ejemplos de cómo usar la CLI de gcloud y la API para recrear las reglas de cortafuegos de VPC predefinidas creadas para redes predeterminadas. Puedes usar los ejemplos para crear reglas similares para tus redes en modo automático y personalizadas. Cada regla de cortafuegos puede incluir intervalos de direcciones IPv4 o IPv6, pero no ambos.

Permitir conexiones de entrada internas entre máquinas virtuales

En los ejemplos siguientes se crea una regla de cortafuegos para permitir las conexiones TCP, UDP e ICMP internas a tus instancias de VM, de forma similar a la regla allow-internal de las redes predeterminadas.

gcloud

Usa el comando gcloud compute firewall-rules create:

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

Haz los cambios siguientes:

  • RULE_NAME: nombre de esta regla de cortafuegos.
  • NETWORK: el nombre de la red a la que se aplica esta regla de cortafuegos. El valor predeterminado es default.
  • ICMP_PROTOCOL: el tipo de protocolo ICMP. Especifica ICMPv4 mediante el nombre de protocolo icmp o el número de protocolo 1. Especifica ICMPv6 mediante el número de protocolo 58.

  • SUBNET_RANGES: uno o varios intervalos de direcciones IP. Si incluye un intervalo de direcciones IP, el tráfico de ese intervalo podrá llegar a cualquier destino de VM de la red de VPC. Puedes especificar intervalos IPv4 o IPv6 en una regla de cortafuegos determinada.

    Intervalos de subred IPv4:

    • Las redes de VPC en modo automático usan intervalos de direcciones IP que están dentro de 10.128.0.0/9.
    • Las redes en modo personalizado pueden usar cualquier intervalo IPv4 válido. Si no usas intervalos contiguos para las subredes de tu red de VPC, puede que tengas que especificar varios intervalos.
    • Puedes usar 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 para permitir el tráfico de todos los intervalos de direcciones IPv4 privadas (intervalos RFC 1918).

    Intervalos de subred IPv6:

    • Si has asignado un intervalo de direcciones IPv6 internas a tu red de VPC, puedes usar ese intervalo como intervalo de origen. Si usas el intervalo IPv6 interno de la red de VPC, la regla de cortafuegos incluirá todos los intervalos de subredes IPv6 internos actuales y futuros. Puedes encontrar el intervalo IPv6 interno de la red VPC con el siguiente comando:

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

      También puede especificar intervalos de subredes IPv6 internas concretos.

    • Para permitir el tráfico de los intervalos de subredes IPv6 externas, debe especificar el intervalo de direcciones IPv6 de cada subred que quiera 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"
  ]
}

Haz los cambios siguientes:

  • PROJECT_ID: ID del proyecto en el que se encuentra la red VPC.
  • RULE_NAME: el nombre de la regla de cortafuegos.
  • NETWORK: el nombre de la red de VPC en la que se crea la regla de cortafuegos. El valor predeterminado es default.
  • ICMP_PROTOCOL: el tipo de protocolo ICMP. Especifica ICMPv4 mediante el nombre de protocolo icmp o el número de protocolo 1. Especifica ICMPv6 mediante el número de protocolo 58.

  • INTERNAL_SOURCE_RANGES: uno o varios intervalos de IP. Para permitir el tráfico interno en todas las subredes de tus redes de VPC, especifica los intervalos de direcciones IP que se usan en tu red de VPC. Puedes especificar intervalos IPv4 o IPv6 en una regla de cortafuegos.

    Intervalos de subred IPv4:

    • Las redes de VPC en modo automático usan intervalos de direcciones IP que están dentro de 10.128.0.0/9.
    • Las redes en modo personalizado pueden usar cualquier intervalo IPv4 válido. Si no usas intervalos contiguos para las subredes de tu red de VPC, puede que tengas que especificar varios intervalos.
    • Puedes usar 10.0.0.0/8,172.16.0.0/12,192.168.0.0/16 para permitir el tráfico de todos los intervalos de direcciones IPv4 privadas (intervalos RFC 1918).

    Intervalos de subred IPv6:

    • Si has asignado un intervalo de direcciones IPv6 internas a tu red de VPC, puedes usar ese intervalo como intervalo de origen. Si usas el intervalo IPv6 interno de la red de VPC, la regla de cortafuegos incluirá todos los intervalos de subredes IPv6 internos actuales y futuros. Puedes encontrar el intervalo IPv6 interno de la red VPC con el siguiente comando:

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

      También puede especificar intervalos de subredes IPv6 internas concretos.

    • Para permitir el tráfico de los intervalos de subredes IPv6 externas, debe especificar el intervalo de direcciones IPv6 de cada subred que quiera incluir.

Permitir conexiones SSH entrantes a máquinas virtuales

En los ejemplos siguientes se crea una regla de cortafuegos para permitir las conexiones SSH a tus instancias de VM, de forma similar a la regla allow-ssh de las redes predeterminadas.

gcloud

Usa el comando gcloud compute firewall-rules create:

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

Haz los cambios siguientes:

  • RULE_NAME: nombre de esta regla de cortafuegos.
  • NETWORK: el nombre de la red a la que se aplica esta regla de cortafuegos. El valor predeterminado es default.

  • RANGES_OUTSIDE_VPC_NETWORK: uno o varios intervalos de direcciones IP. Puedes especificar intervalos IPv4 o IPv6 en una regla de firewall determinada. Te recomendamos que especifiques los intervalos de direcciones IP concretos desde los que necesitas permitir el acceso, en lugar de todas las fuentes IPv4 o IPv6.

    • Incluir 35.235.240.0/20 en los intervalos de origen permite establecer conexiones SSH mediante el reenvío de TCP de Identity-Aware Proxy (IAP) si se cumplen todos los demás requisitos. Para obtener más información, consulta Usar IAP para reenviar TCP.
    • Si se usa 0.0.0.0/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv4, incluidos los que están fuera de Google Cloud.
    • Si se usa ::/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv6, incluidos los que están fuera de 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"
  ]
}

Haz los cambios siguientes:

  • PROJECT_ID: ID del proyecto en el que se encuentra la red VPC.
  • RULE_NAME: el nombre de la regla de cortafuegos.
  • NETWORK: el nombre de la red de VPC en la que se crea la regla de cortafuegos.

  • RANGES_OUTSIDE_VPC_NETWORK: uno o varios intervalos de direcciones IP. Puedes especificar intervalos IPv4 o IPv6 en una regla de firewall determinada. Te recomendamos que especifiques los intervalos de direcciones IP concretos desde los que necesitas permitir el acceso, en lugar de todas las fuentes IPv4 o IPv6.

    • Incluir 35.235.240.0/20 en los intervalos de origen permite establecer conexiones SSH mediante el reenvío de TCP de Identity-Aware Proxy (IAP) si se cumplen todos los demás requisitos. Para obtener más información, consulta Usar IAP para reenviar TCP.
    • Si se usa 0.0.0.0/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv4, incluidos los que están fuera de Google Cloud.
    • Si se usa ::/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv6, incluidos los que están fuera de Google Cloud.

Permitir conexiones RDP de entrada a las VMs

En los siguientes ejemplos se crea una regla de cortafuegos para permitir las conexiones del protocolo de escritorio remoto (RDP) de Microsoft a tus instancias de VM, de forma similar a la regla allow-rdp de las redes predeterminadas.

gcloud

Usa el comando gcloud compute firewall-rules create:

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

Haz los cambios siguientes:

  • RULE_NAME: nombre de esta regla de cortafuegos.
  • NETWORK: el nombre de la red a la que se aplica esta regla de cortafuegos. El valor predeterminado es default.

  • RANGES_OUTSIDE_VPC_NETWORK: uno o varios intervalos de direcciones IP. Puedes especificar intervalos IPv4 o IPv6 en una regla de firewall determinada. Te recomendamos que especifiques los intervalos de direcciones IP concretos desde los que necesitas permitir el acceso, en lugar de todas las fuentes IPv4 o IPv6.

    • Si se incluye 35.235.240.0/20 en los intervalos de origen, se permiten las conexiones RDP mediante el reenvío de TCP de Identity-Aware Proxy (IAP) si se cumplen todos los demás requisitos. Para obtener más información, consulta Usar IAP para reenviar TCP.
    • Si se usa 0.0.0.0/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv4, incluidos los que están fuera de Google Cloud.
    • Si se usa ::/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv6, incluidos los que están fuera de 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"
  ]
}

Haz los cambios siguientes:

  • PROJECT_ID: ID del proyecto en el que se encuentra la red VPC.
  • RULE_NAME: el nombre de la regla de cortafuegos.
  • NETWORK: el nombre de la red de VPC en la que se crea la regla de cortafuegos.

  • RANGES_OUTSIDE_VPC_NETWORK: uno o varios intervalos de direcciones IP. Puedes especificar intervalos IPv4 o IPv6 en una regla de firewall determinada. Te recomendamos que especifiques los intervalos de direcciones IP concretos desde los que necesitas permitir el acceso, en lugar de todas las fuentes IPv4 o IPv6.

    • Si se incluye 35.235.240.0/20 en los intervalos de origen, se permiten las conexiones RDP mediante el reenvío de TCP de Identity-Aware Proxy (IAP) si se cumplen todos los demás requisitos. Para obtener más información, consulta Usar IAP para reenviar TCP.
    • Si se usa 0.0.0.0/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv4, incluidos los que están fuera de Google Cloud.
    • Si se usa ::/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv6, incluidos los que están fuera de Google Cloud.

Permitir conexiones ICMP entrantes a las VMs

En los ejemplos siguientes se crea una regla de cortafuegos para permitir las conexiones ICMP a tus instancias de VM, de forma similar a la regla allow-icmp de las redes predeterminadas.

gcloud

Usa el comando gcloud compute firewall-rules create:

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

Haz los cambios siguientes:

  • RULE_NAME: el nombre de la regla de cortafuegos.
  • NETWORK: el nombre de la red a la que se aplica esta regla de cortafuegos. El valor predeterminado es default.
  • ICMP_PROTOCOL: el tipo de protocolo ICMP. Especifica ICMPv4 mediante el nombre de protocolo icmp o el número de protocolo 1. Especifica ICMPv6 mediante el número de protocolo 58.

  • RANGES_OUTSIDE_VPC_NETWORK: uno o varios intervalos de direcciones IP. Puedes especificar intervalos IPv4 o IPv6 en una regla de firewall determinada. Te recomendamos que especifiques los intervalos de direcciones IP concretos desde los que necesitas permitir el acceso, en lugar de todas las fuentes IPv4 o IPv6.

    • Si se usa 0.0.0.0/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv4, incluidos los que están fuera de Google Cloud.
    • Si se usa ::/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv6, incluidos los que están fuera de 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"
  ]
}

Haz los cambios siguientes:

  • PROJECT_ID: ID del proyecto en el que se encuentra la red VPC.
  • RULE_NAME: el nombre de la regla de cortafuegos.
  • NETWORK: el nombre de la red de VPC en la que se crea la regla de cortafuegos.
  • ICMP_PROTOCOL: el tipo de protocolo ICMP que se va a usar. Especifica ICMPv4 mediante el nombre de protocolo icmp o el número de protocolo 1. Especifica ICMPv6 mediante el número de protocolo 58.

  • RANGES_OUTSIDE_VPC_NETWORK: uno o varios intervalos de direcciones IP. Puedes especificar intervalos IPv4 o IPv6 en una regla de firewall determinada. Te recomendamos que especifiques los intervalos de direcciones IP concretos desde los que necesitas permitir el acceso, en lugar de todas las fuentes IPv4 o IPv6.

    • Si se usa 0.0.0.0/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv4, incluidos los que están fuera de Google Cloud.
    • Si se usa ::/0 como intervalo de origen, se permite el tráfico de todos los orígenes IPv6, incluidos los que están fuera de Google Cloud.

Otros ejemplos de configuración

En la figura 1 se describe un ejemplo de configuración de una red de VPC llamada my-network. La red contiene lo siguiente:

  • Una subred llamada subnet1, con el intervalo de IP 10.240.10.0/24 y una sola instancia
  • Una subred llamada subnet2, con el intervalo de IP 192.168.1.0/24
  • Una instancia llamada vm1 en subnet2 con la etiqueta webserver y la dirección IP interna 192.168.1.2
  • Una instancia llamada vm2 en subnet2 con una etiqueta database y una dirección IP interna 192.168.1.3
Esta red de VPC contiene dos subredes, cada una de las cuales contiene máquinas virtuales. La subred 2 contiene máquinas virtuales a las que se les han asignado etiquetas de red.
Imagen 1. Esta red de VPC contiene dos subredes, cada una con máquinas virtuales. La subred 2 contiene máquinas virtuales a las que se les han asignado etiquetas de red (haz clic para ampliar).

Ejemplo 1: Denegar todas las conexiones TCP entrantes, excepto las que se dirijan al puerto 80 desde subnet1

En este ejemplo, se crea un conjunto de reglas de cortafuegos de VPC que deniegan todas las conexiones TCP entrantes, excepto las conexiones destinadas al puerto 80 desde subnet1.

gcloud

  1. Crea una regla de cortafuegos para denegar todo el tráfico TCP de entrada a las instancias etiquetadas con 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

    Sustituye NETWORK_NAME por el nombre de la red.

  2. Crea una regla de cortafuegos para permitir que todas las direcciones IP de subnet1 (10.240.10.0/24) accedan al puerto TCP 80 en las instancias etiquetadas con 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

    Sustituye NETWORK_NAME por el nombre de la red.

Ejemplo 2: Denegar todas las conexiones TCP de salida, excepto las que se dirijan al puerto 80 de vm1

gcloud

  1. Crea una regla de cortafuegos para denegar todo el tráfico TCP de salida.

    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

    Sustituye NETWORK_NAME por el nombre de la red.

  2. Crea una regla de cortafuegos para permitir el tráfico TCP destinado al puerto 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

    Sustituye NETWORK_NAME por el nombre de la red.

Ejemplo 3: Permitir conexiones TCP salientes al puerto 443 de un host externo

Crea una regla de cortafuegos que permita que las instancias etiquetadas con webserver envíen tráfico TCP de salida al puerto 443 de una dirección IP externa de ejemplo, 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

Sustituye NETWORK_NAME por el nombre de la red.

Ejemplo 4: Permitir conexiones SSH de vm2 a vm1

Crea una regla de cortafuegos que permita que el tráfico SSH de las instancias con la etiqueta database (vm2) llegue a las instancias con la etiqueta 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

Sustituye NETWORK_NAME por el nombre de la red.

Ejemplo 5: Permitir TCP:1443 desde el servidor web a la base de datos mediante cuentas de servicio

Para obtener más información sobre las cuentas de servicio y los roles, consulta el artículo Asignar roles a cuentas de servicio.

En la situación que se muestra en la figura 2, hay dos aplicaciones que se escalan automáticamente mediante plantillas: una aplicación de servidor web asociada a una cuenta de servicio my-sa-webserver y una aplicación de base de datos asociada a una cuenta de servicio my-sa-database. Un administrador de seguridad quiere permitir el tráfico TCP de las VMs con la cuenta de servicio my-sa-webserver al puerto de destino 1443 de las VMs con la cuenta de servicio my-sa-database.

Una regla de cortafuegos permite el tráfico de una VM con la cuenta de servicio my-sa-webserver al puerto 1443 de una VM con la cuenta de servicio my-sa-database.
Imagen 2. Una regla de cortafuegos permite el tráfico de una VM con la cuenta de servicio my-sa-webserver al puerto 1443 de una VM con la cuenta de servicio my-sa-database (haz clic para ampliar).

Los pasos de configuración, incluida la creación de las cuentas de servicio, son los siguientes.

gcloud

  1. Un EDITOR o un PROPIETARIO del proyecto crea las cuentas de servicio my-sa-webserver y my-sa-database.

    gcloud iam service-accounts create my-sa-webserver \
    --display-name "webserver service account"

    gcloud iam service-accounts create my-sa-database \
    --display-name "database service account"

  2. El PROPIETARIO de un proyecto asigna al desarrollador del servidor web web-dev@example.com el rol serviceAccountUser para la cuenta de servicio my-sa-webserver. Para ello, define una política de gestión de identidades y accesos (IAM).

    gcloud iam service-accounts add-iam-policy-binding \
my-sa-webserver@my-project.iam.gserviceaccount.com \
    --member='user:web-dev@example.com' \
    --role='roles/iam.serviceAccountUser'

  3. El PROPIETARIO de un proyecto asigna al desarrollador de bases de datos db-dev@example.com el rol serviceAccountUser a la cuenta de servicio my-sa-database configurando una política de gestión de identidades y accesos.

    gcloud iam service-accounts add-iam-policy-binding \
my-sa-database@my-project.iam.gserviceaccount.com \
    --member='user:db-dev@example.com' \
    --role='roles/iam.serviceAccountUser'

  4. El desarrollador web-dev@example.com, que tiene el rol de administrador de instancias, crea una plantilla de instancia de servidor web y autoriza a las instancias a ejecutarse como cuenta de servicio my-sa-webserver.

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

  5. El desarrollador db-dev@example.com, que tiene el rol de administrador de instancias, crea la plantilla de instancia de base de datos y autoriza a las instancias a ejecutarse como cuenta de servicio my-sa-database.

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

  6. El administrador de seguridad crea una regla de cortafuegos que permite el tráfico TCP de las VMs con la cuenta de servicio my-sa-webserver para llegar al puerto 1443 de las VMs con la cuenta de servicio my-sa-database.

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

Solución de problemas

Mensajes de error al crear o actualizar una regla de cortafuegos de VPC

Es posible que aparezca uno de los siguientes mensajes de error:

  • Should not specify destination range for ingress direction.

    Los intervalos de destino no son parámetros válidos para las reglas de cortafuegos de entrada. Se presupone que las reglas de cortafuegos son reglas de entrada, a menos que se especifique una dirección de EGRESS. Si creas una regla que no especifica una dirección, se creará como una regla de entrada, que no permite un intervalo de destino. Además, los intervalos de origen no son parámetros válidos para las reglas de salida.

  • Firewall direction cannot be changed once created.

    No puedes cambiar la dirección de una regla de cortafuegos que ya se ha creado. Tienes que crear una regla con los parámetros correctos y, a continuación, eliminar la antigua.

  • Firewall traffic control action cannot be changed once created.

    No puedes cambiar la acción de una regla de cortafuegos que ya tengas. Tienes que crear una regla con los parámetros correctos y, a continuación, eliminar la antigua.

  • Service accounts must be valid RFC 822 email addresses. La cuenta de servicio especificada en la regla de cortafuegos debe ser una dirección de correo electrónico con el formato de 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. No puedes especificar cuentas de servicio y etiquetas en la misma regla.

    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.

Error de recurso no encontrado

Cuando eliminas una red de VPC o una regla de cortafuegos, es posible que veas un mensaje similar al siguiente: The resource "aet-uscentral1-subnet--1-egrfw" was not found.

Este error puede impedir que elimines una regla de cortafuegos implícita o que veas sus detalles. Una regla de cortafuegos que se encuentre en este estado también puede impedir que elimines una red de VPC.

Para eliminar una regla de cortafuegos o una red que se haya bloqueado de esta forma, primero elimina el conector de acceso a VPC sin servidor asociado y, a continuación, vuelve a intentarlo. Para obtener más información sobre cómo eliminar un conector de acceso a VPC sin servidor, consulta Eliminar un conector.

Error de demasiados cortafuegos grandes

Es posible que veas el siguiente mensaje de error: Google Compute Engine: The network contains too many large firewalls.

Para mantener la seguridad y el rendimiento, hay un límite en la complejidad y el número de reglas de cortafuegos que se pueden implementar en una red VPC. Si aparece este error, pide al equipo de gestión de tu cuenta que simplifique o consolide tus reglas de cortafuegos.

No se puede conectar a la instancia de VM

Si no puedes conectarte a una instancia de VM, comprueba las reglas de tu cortafuegos.

gcloud

  1. Si vas a iniciar la conexión desde otra instancia de máquina virtual, enumera las reglas de cortafuegos de salida de esa instancia.

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

    Sustituye NETWORK_NAME por el nombre de la red.

  2. Comprueba si alguna regla de salida deniega la IP de destino. La regla con la prioridad más alta (el número de prioridad más bajo) anula las reglas de menor prioridad. Si dos reglas tienen la misma prioridad, prevalece la regla de denegación.

  3. Comprueba la regla de cortafuegos de entrada de la red que contiene la instancia 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
      )"

    Sustituye NETWORK_NAME por el nombre de la red.

    Ejemplo de salida. El resultado dependerá de tu lista de reglas de cortafuegos.

    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. También puedes hacer pruebas de conectividad hacia o desde instancias de VM en una red de VPC a otra red de VPC o a una red de nube que no sea de Google para solucionar problemas si el tráfico se rechaza por alguna regla de cortafuegos de entrada o de salida. Para obtener más información sobre cómo ejecutar las pruebas de conectividad para solucionar problemas en distintos casos, consulta Ejecutar pruebas de conectividad.

¿Está habilitada o inhabilitada mi regla de cortafuegos de VPC?

Para ver si una regla de cortafuegos está habilitada o inhabilitada, consulta los detalles de la regla de cortafuegos.

En la Google Cloud console, busca Habilitado o Inhabilitado en la sección Cumplimiento.

En el resultado de la herramienta de línea de comandos gcloud, busca el campo disabled. Si aparece disabled:false, la regla está habilitada y se aplica. Si pone disabled: true, la regla está inhabilitada.

¿Qué regla se aplica a una instancia de VM?

Después de crear una regla, puede comprobar si se está aplicando correctamente en una instancia concreta. Para obtener más información, consulta el artículo sobre cómo listar las reglas de cortafuegos de una interfaz de red de una instancia de VM.

Las reglas de cortafuegos de VPC con etiquetas de origen no se aplican inmediatamente

Las reglas de cortafuegos de entrada que usan etiquetas de origen pueden tardar en propagarse. Para obtener más información, consulta las consideraciones relacionadas con las etiquetas de origen de las reglas de cortafuegos de entrada.

Siguientes pasos