> ## Documentation Index
> Fetch the complete documentation index at: https://docs.basaltic.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Grupos de seguridad

> Stateful permite que se adjunten reglas a una interfaz: la postura predeterminada, lo que una regla puede nombrar y lo que la plataforma hace cumplir independientemente.

Un grupo de seguridad es un conjunto de **Reglas de permiso stateful**No hay reglas de denegación ni ordenación: un paquete es permitido si cualquier regla en cualquier grupo adjunto a la interfaz lo permite, y se descarta de lo contrario.

<Warning>
  Las reglas no hacen nada hasta que el grupo está conectado a una interfaz. Un grupo lleno de reglas cuidadosamente escritas a las que ninguna interfaz pertenece no tiene efecto en ninguna parte.
</Warning>

<CardGroup cols={2}>
  <Card title="La postura predeterminada" icon="lock" href="#the-default-posture">
    Lo que hace una interfaz sin grupo, y la única regla con la que comienza un nuevo grupo.
  </Card>

  <Card title="Reglas de escritura" icon="list-checks" href="#rules">
    Campos obligatorios, la fuente que no es opcional y por qué no hay actualización.
  </Card>

  <Card title="Adjuntar" icon="link" href="#attaching-groups-to-an-interface">
    La membresía es un conjunto que reemplazas, no una lista a la que agregas.
  </Card>

  <Card title="Reglas de la plataforma" icon="shield-alert" href="#what-the-platform-enforces-regardless">
    Tráfico que siempre está permitido, y el puerto que siempre está bloqueado.
  </Card>
</CardGroup>

<a id="the-default-posture" />

## La postura predeterminada

Dos valores por defecto diferentes importan aquí, y confundirlos es la fuente habitual de "mis reglas no hacen nada".

<Tabs>
  <Tab title="Una interfaz en ningún grupo">
    **Default deny, ambas direcciones.** Cada paquete es descartado excepto cuando la propia plataforma siempre activa lo permite. No adjuntar ningún grupo de seguridad no es la opción permisiva, es la cerrada.
  </Tab>

  <Tab title="Un grupo recién creado">
    Por defecto se deniegan ambas direcciones, **más una regla**: salida, todos los protocolos, a `0.0.0.0/0`. Así que adjuntar un grupo nuevo le da a una interfaz todo IPv4 saliente y nada entrante en absoluto. Elimine esa regla si desea bloquear la salida.
  </Tab>
</Tabs>

<Warning>
  Esa regla de salida predeterminada es **IPv4 only**. Una interfaz de doble pila no tiene salida `::/0` hasta que añadas una regla de salida `ipv6` tú mismo, por lo que una instancia habilitada para v6 que funciona sobre IPv4 puede fallar silenciosamente sobre IPv6 con un grupo que parece estar completamente abierto.
</Warning>

<a id="rules" />

## Reglas

<Tabs>
  <Tab title="Console">
    Vaya a **Networking → Security Groups** — **Create Security Group** hace uno, con un **Name** y una **Description** opcional — luego ábralo y elija **Add inbound rule** o **Add outbound rule**. El botón que presionaste es la dirección de la regla; no hay campo de dirección en el diálogo, y el bloque donde nombras el otro extremo se encabeza **Source** o **Destination** para que coincida.

    Elija un **Service** preestablecido — **HTTPS (443)**, **SSH (22)**, **PostgreSQL (5432)** y así sucesivamente — o déjelo en **Custom** y establezca **IP
    Version**, **Protocol** y **Port Range** usted mismo. **Port Range** es un campo que toma un solo puerto o un rango, donde la API toma `port_min` y `port_max` por separado. A continuación, elija **CIDR** o **Security
    Group** para la fuente y confirme con **Add Rule**.

    Las pestañas **Inbound** y **Outbound** del grupo muestran lo que contiene, cada fila con una acción **Delete rule**.
  </Tab>

  <Tab title="API">
    ```bash theme={null}
    POST /v1/security-groups/{security_group_id}/rules
    {
      "direction": "ingress",
      "protocol": "tcp",
      "port_min": 443,
      "port_max": 443,
      "remote_cidr": "0.0.0.0/0"
    }
    ```
  </Tab>

  <Tab title="CLI">
    ```bash theme={null}
    basaltic network security-group-rule create <security-group-id> \
      --direction ingress --protocol tcp --port-min 443 --port-max 443 \
      --remote-cidr 0.0.0.0/0
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    rule, err := network.New(cfg).CreateSecurityGroupRule(ctx, securityGroupID,
        &network.SecurityGroupRuleCreateRequest{
            Direction:  "ingress",
            Protocol:   "tcp",
            PortMin:    basaltic.Int(443),
            PortMax:    basaltic.Int(443),
            RemoteCIDR: basaltic.String("0.0.0.0/0"),
        })
    ```
  </Tab>
</Tabs>

<ResponseField name="direction" type="ingress | egress" required>
  Para una regla `egress`, `remote_cidr` y `source_security_group_id` nombran el **destination**. Los nombres de los campos no cambian con la dirección.
</ResponseField>

<ResponseField name="protocol" type="tcp | udp | icmp | all" required />

<ResponseField name="ethertype" type="ipv4 | ipv6">
  Por defecto es `ipv4`. Una regla coincide con una familia solamente; escriba dos reglas para ambas.
</ResponseField>

<ResponseField name="port_min / port_max" type="integer">
  Requerido para `tcp` y `udp`, y rechazado sin ellos. Ignorado — y borrado — para `icmp` y `all`. El rango debe satisfacer `0 ≤ port_min ≤ port_max ≤ 65535`. Para un solo puerto, configure ambos en él.
</ResponseField>

<ResponseField name="remote_cidr / source_security_group_id" type="string | uuid" required>
  **Se requiere exactamente uno de los dos.** Son mutuamente exclusivos, y omitir ambos es rechazado — no hay una abreviatura de "cualquier fuente"; escriba `0.0.0.0/0` o `::/0` explícitamente. `remote_cidr` debe coincidir con el `ethertype` de la regla.
</ResponseField>

Las reglas son solo de creación y eliminación; no hay actualización. Para cambiar uno, elimínelo y cree el reemplazo.

<a id="naming-another-group-as-the-source" />

### Nombrar otro grupo como origen

<Tabs>
  <Tab title="Console">
    En **Add inbound rule**, cambie el bloque **Source** de **CIDR** a **Security Group**, luego **Pick a source security group**.
  </Tab>

  <Tab title="API">
    ```json theme={null}
    { "direction": "ingress", "protocol": "tcp", "port_min": 5432, "port_max": 5432,
      "source_security_group": "<the app tier's group>" }
    ```
  </Tab>

  <Tab title="CLI">
    ```bash theme={null}
    basaltic network security-group-rule create <db-tier-group-id> \
      --direction ingress --protocol tcp --port-min 5432 --port-max 5432 \
      --source-security-group <app-tier-group-id>
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    rule, err := network.New(cfg).CreateSecurityGroupRule(ctx, dbTierGroupID,
        &network.SecurityGroupRuleCreateRequest{
            Direction:             "ingress",
            Protocol:              "tcp",
            PortMin:               basaltic.Int(5432),
            PortMax:               basaltic.Int(5432),
            SourceSecurityGroup: basaltic.String(appTierGroupID),
        })
    ```
  </Tab>
</Tabs>

Esto significa "cualquier carga de trabajo en ese grupo", coincidente con las direcciones de sus miembros actuales. Al agregar una instancia al nivel de aplicación, la base de datos se vuelve accesible desde ella sin cambiar las reglas, y al eliminar una se cierra de nuevo. Le ahorra mantener listas de CIDR que se desactualizan cada vez que se escala un nivel.

### Stateful

El tráfico de retorno de una conexión permitida se permite automáticamente. No se escribe una regla de espejo en la dirección opuesta — una regla de entrada para TCP 443 ya deja salir las respuestas.

<a id="attaching-groups-to-an-interface" />

## Adjuntar grupos a una interfaz

La membresía pertenece a la interfaz, no al grupo. No hay nada en la página de un grupo de seguridad que lo conecte a nada.

<Tabs>
  <Tab title="Console">
    Abra la NIC en **Networking → Interfaces** y elija **Attach
    security group**; el diálogo señala que las reglas del grupo "comienzan a filtrar el tráfico de esta interfaz tan pronto como se adjunta" Su pestaña **Security
    groups** enumera lo que se adjunta, cada fila con una acción **Detach security
    group**.

    La consola agrega y elimina un grupo a la vez y reconstruye la lista completa para usted, por lo que no tiene que pensar en la semántica de conjuntos a continuación.
  </Tab>

  <Tab title="API">
    ```bash theme={null}
    GET /v1/interfaces/{interface_id}/security-groups
    PUT /v1/interfaces/{interface_id}/security-groups
    { "security_groups": ["<sg-a>", "<sg-b>"] }
    ```
  </Tab>

  <Tab title="CLI">
    ```bash theme={null}
    basaltic network interface list-security-groups <interface-id>
    basaltic network interface set-security-group <interface-id> \
      --security-groups <sg-a>,<sg-b>
    ```

    `--security-groups` es el conjunto completo, no una adición — la misma semántica de reemplazo que el `PUT`.
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    n := network.New(cfg)
    current, err := n.ListInterfaceSecurityGroups(ctx, interfaceID)
    groups, err := n.SetInterfaceSecurityGroups(ctx, interfaceID,
        &network.InterfaceSecurityGroupsRequest{
            SecurityGroups: []string{groupA, groupB},
        })
    ```
  </Tab>
</Tabs>

<Warning>
  `PUT` **reemplaza** toda la membresía atómicamente. Es un conjunto, no un apéndice: envíe la lista completa que desee, porque cualquier cosa que deje fuera está separada. Enviar `{"security_groups": []}` quita todos los grupos de la interfaz, lo que deja que se descarte todo.

  Esta es la trampa que la consola esconde — lee la lista actual con `GET`, añade o suelta su id, y envía todo de vuelta.
</Warning>

Cada id tiene que ser un grupo que pertenece a tu cuenta. Cuando varios grupos se aplican a una interfaz, sus reglas de permiso están **unidas** — una interfaz es al menos tan abierta como su grupo más permisivo. No se puede restar con un grupo de seguridad; para restringir una interfaz, elimine el grupo que permite el tráfico.

Se rechaza la eliminación de un grupo mientras todavía pertenezca alguna interfaz a él. Vacíe la membresía en cada interfaz primero. `name` es inmutable; `description` y `tags` pueden ser parcheados.

<a id="what-the-platform-enforces-regardless" />

## Lo que la plataforma hace cumplir sin importar

Una pequeña banda de reglas se sienta por encima de la tuya. No puedes anularlos ni eliminarlos a través de esta API.

<a id="always-allowed" />

### Siempre está permitido

DHCP, descubrimiento de vecinos IPv6 y el punto final de metadatos de enlace local en `169.254.169.254`. Cada instancia necesita estos para alquilar su dirección y para llegar a los metadatos de la instancia en el arranque, por lo que sobreviven a una postura de denegación predeterminada; de lo contrario, una instancia bloqueada correctamente nunca podría terminar de arrancar.

<a id="always-blocked-outbound-tcp-25-to-the-internet" />

### Siempre bloqueado: TCP 25 saliente a Internet

El SMTP directo a MX desde una instancia comprometida o alquilada es la forma más rápida de que un rango de direcciones aterrice en una lista de bloqueo de spam, y el costo de eso recae en todos los que comparten el rango. El sobre lleva su dirección, por lo que el bloqueo está en el puerto 25 específicamente.

<Note>
  Los puertos de envío **465, 587 y 2525 no están bloqueados**. El correo entregado a un proveedor autenticado sale de las direcciones de ese proveedor llevando la reputación de ese proveedor, por lo que bloquearlas no compra nada y rompe una gran cantidad de software que solo habla SMTP.

  La eliminación del puerto 25 también excluye los destinos privados, por lo que su propio servidor de correo dentro de la VPC permanece accesible desde otra instancia.
</Note>

<a id="next" />

## Siguiente

<CardGroup cols={2}>
  <Card title="Interfaces" icon="network" href="/es/networking/interfaces">
    Qué es una NIC y cómo obtiene sus grupos de seguridad.
  </Card>

  <Card title="Enrutamiento" icon="route" href="/es/networking/routing">
    Los grupos de seguridad deciden el último salto. El enrutamiento decide si el paquete llega alguna vez.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.