> ## 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. # IP flotantes > Direcciones virtuales públicas o privadas que se mueven independientemente de una NIC, con adjunto dirigido a la dirección y estado de los miembros. Una dirección IP flotante es una dirección IPv4 o IPv6 asignada por separado. Las direcciones públicas provienen del grupo público regional; las direcciones privadas provienen de una subred seleccionada y permanecen dentro de su VPC. Ambos se traducen a una dirección en la NIC de destino, por lo que la conexión o el movimiento de uno no reconfigura el invitado. Una IP flotante pública no es accesible simplemente porque la haya asignado. Para llegar a una instancia desde Internet se necesitan cuatro cosas, y tres de ellas no tienen nada que ver con la dirección en sí. **Asignar una IP flotante y adjuntarla no es suficiente.** La subred de la instancia también necesita una puerta de enlace de Internet adjunta a la VPC *y* una ruta `0.0.0.0/0` que apunte a esa puerta de enlace. Sin la ruta, el tráfico de respuesta no tiene adónde ir, y desde el exterior se ve exactamente como si el paquete entrante se hubiera caído, por lo que pasa la tarde depurando la dirección equivocada. La API rechaza el adjunto por esta razón en lugar de entregarle una dirección muerta. ## La cadena de accesibilidad ```mermaid theme={null} flowchart LR NET([Internet]) --> IGW["Internet gateway
attached to the VPC"] IGW --> RT{"Subnet's route table
0.0.0.0/0 → that gateway?"} RT -- no --> D1["Reply has no way out.
Looks like inbound blackhole."] RT -- yes --> FIP["Floating IP
attached to the NIC"] FIP --> SG{"Security group
allows the port?"} SG -- no --> D2["Dropped at the interface"] SG -- yes --> VM([Instance]) ``` Vaya a **Networking → Internet Gateways** y elija **Create Internet Gateway**. Solo se necesita un **Name** y la puerta de enlace es "Creado de forma independiente; adjúntelo a una VPC de la lista para comenzar a enrutar el tráfico de salida". Ábrelo y elige **Attach**, elige el **VPC** y confirma con **Attach**. **Status** cambia de **Detached** a **Attached** y se completa con **Attached VPC**. ```bash theme={null} POST /v1/internet-gateways { "name": "main" } POST /v1/internet-gateways/{id}/attach { "vpc": "" } ``` ```bash theme={null} basaltic network internet-gateway create --name main basaltic network internet-gateway attach --vpc ``` ```go theme={null} n := network.New(cfg) g, err := n.CreateInternetGateway(ctx, &network.InternetGatewayCreateRequest{ Name: "main", }) g, err = n.AttachInternetGateway(ctx, g.ID, &network.InternetGatewayAttachRequest{ VPC: vpcID, }) ``` La conexión no crea rutas. Solo hace que la puerta de enlace esté disponible como un destino de ruta. Vaya a **Networking → Route Tables** y abra la tabla que usa la subred — la página de la subred la nombra bajo **Route table**. Elija **Add Route**, establezca **Destination CIDR** en `0.0.0.0/0`, establezca **Target type** en **Internet Gateway**, elija la puerta de enlace en **Internet gateway** y confirme con **Add Route**. Si el selector está vacío y dice "No hay IGW adjunto a esta VPC. Adjunte uno primero.", todavía está en el paso anterior. ```bash theme={null} POST /v1/route-tables/{route_table_id}/routes { "destination_cidr": "0.0.0.0/0", "target_internet_gateway": "" } ``` ```bash theme={null} basaltic network route create \ --destination-cidr 0.0.0.0/0 --target-internet-gateway ``` ```go theme={null} r, err := network.New(cfg).CreateRoute(ctx, routeTableID, &network.RouteCreateRequest{ DestinationCIDR: "0.0.0.0/0", TargetInternetGateway: basaltic.String(gatewayID), }) ``` Esto es lo que hace que la subred sea pública. Es también lo que hace que exista la ruta *reply*. Vaya a **Networking → Floating IPs**, elija **Allocate Floating IP** si no tiene una de repuesto, luego abra la dirección y elija **Attach**. Seleccione la NIC bajo **Interface**; su dirección coincidente se selecciona como el destino. Confirme con **Attach floating IP**. El mismo enlace está en la NIC: ábrala en **Networking → Interfaces** y elija **Attach floating IP**. ```bash theme={null} POST /v1/floating-ips/{floating_ip_id}/attach { "interface": "", "address_id": "" } ``` ```bash theme={null} basaltic network floating-ip attach \ --interface --address-id ``` ```go theme={null} fip, err := network.New(cfg).AttachFloatingIP(ctx, floatingIPID, &network.AttachFloatingIPRequest{Interface: interfaceID, AddressID: addressID}) ``` Si la subred no tiene una ruta predeterminada a una puerta de enlace de Internet, esto falla con `400`: "la subred de la interfaz no tiene una ruta predeterminada (0.0.0.0/0) a una puerta de enlace de Internet; adjunte una puerta de enlace de Internet a la VPC y agregue una ruta predeterminada primero". La consola muestra el mismo texto bajo **Failed to attach floating IP**. Abra la NIC en **Networking → Interfaces** y elija **Attach security group**. Sus reglas "comienzan a filtrar el tráfico de esta interfaz tan pronto como se conecta". ```bash theme={null} PUT /v1/interfaces/{interface_id}/security-groups { "security_groups": [""] } ``` ```bash theme={null} basaltic network interface set-security-group \ --security-groups ``` ```go theme={null} groups, err := network.New(cfg).SetInterfaceSecurityGroups(ctx, interfaceID, &network.InterfaceSecurityGroupsRequest{ SecurityGroups: []string{securityGroupID}, }) ``` Una interfaz en ningún grupo de seguridad deja caer todo. [Grupos de seguridad](/es/networking/security-groups) cubre la postura predeterminada. **Create VPC** en la consola realiza los dos primeros pasos por usted. Active **Internet gateway** en **Internet access** y solicite al menos una subred pública, y el flujo de trabajo ejecutará **Create internet gateway**, **Attach internet gateway** y **Configure public internet route** como parte del aprovisionamiento. La IP flotante y el grupo de seguridad son todavía tuyo para hacer después. El guardia corre en ambas direcciones. Eliminar la ruta `0.0.0.0/0` mientras las IP flotantes todavía dependen de ella también se rechaza: "no se puede eliminar la ruta predeterminada: *N* IP(s) flotantes en las subredes de esta tabla de rutas dependen de ella para la accesibilidad a Internet — desacoplarlas primero". Cualquier otra ruta se elimina normalmente, y también la ruta predeterminada una vez que no se adjunta nada. ## Asignación de una dirección Elija `visibility` (`public` por defecto o `private`) y `family` (`ipv4` por defecto o `ipv6`) en la asignación. Estos valores son inmutables. La dirección es asignada por la plataforma. Una asignación privada también requiere `subnet`. Vaya a **Networking → Floating IPs** y elija **Allocate Floating IP**. Elija **Visibility** y **Family** y seleccione una subred para una asignación privada. Añade una **Description** y **Tags** si lo deseas. Confirme con **Allocate IP**. ```bash theme={null} POST /v1/floating-ips { "description": "web front door" } # IPv4 (the default) { "description": "web front door", "family": "ipv6" } ``` ```bash theme={null} basaltic network floating-ip create --description "web front door" basaltic network floating-ip create --description "web front door" --family ipv6 ``` ```go theme={null} fip, err := network.New(cfg).CreateFloatingIP(ctx, &network.FloatingIPCreateRequest{ Description: basaltic.String("web front door"), Family: basaltic.Ptr(network.IPFamilyIPv6), // omit for IPv4 }) ``` Una dirección IPv4 cuenta contra su cuota `floating_ips_v4`, la misma que una dirección de puerta de enlace NAT; una dirección IPv6 cuenta contra `floating_ips_v6`. Las dos son asignaciones separadas: una dirección v4 es una parte del escaso bloque IPv4 de la región, una v6 no lo es. ## Anexo público y privado Lee el array `addresses` de la NIC de destino y pasa su ID de hijo de familia coincidente como `address_id` junto con `interface`. Una NIC puede tener una IP flotante pública y una privada por familia: como máximo cuatro asignaciones con los límites de direcciones actuales. Un FIP IPv4 público y privado pueden traducirse a la misma dirección IPv4 de invitado; lo mismo es cierto para IPv6. La IPv4 pública requiere `0.0.0.0/0` a una puerta de enlace de Internet. IPv6 público requiere `::/0` a una puerta de enlace de Internet y una dirección IPv6 directamente adjunta. NAT66 asigna el FIP a la dirección IPv6 primaria de la NIC `/128`, ya sea que esa dirección sea global o ULA. Las nuevas conexiones salientes desde esa dirección de destino utilizan el FIP público mientras están conectadas. Si el destino tiene una dirección IPv6 global, tanto esa dirección nativa como la IP flotante siguen siendo accesibles, sujetas a las rutas de la subred y las reglas de grupo de seguridad. Las respuestas utilizan la dirección a la que se conectó el cliente. Adjuntar o desvincular el FIP no requiere cambios de dirección de invitado. Otras direcciones globales dentro de la NIC `/96` mantienen su enrutamiento nativo. El tráfico ULA no traducido no puede salir a la Internet pública. Los FIP privados no necesitan una puerta de enlace de Internet. Su subred de asignación y la NIC de destino deben estar en la misma VPC; pueden estar en subredes diferentes. La dirección permanece reservada en su subred de asignación hasta que se libera, incluso mientras está desconectada. Las asignaciones privadas traducen el tráfico entrante y sus respuestas, sin reemplazar la dirección de origen de la NIC para conexiones salientes no relacionadas. Son útiles para identidades de servicio privado y balanceadores de carga personalizados. Desconectar elimina la asignación pero mantiene la asignación. No asigna una dirección pública de reemplazo. La dirección de invitado permanece sin cambios. Sin un FIP público, IPv4 puede usar una puerta de enlace NAT, mientras que una dirección IPv6 global nativa puede usar su ruta de Internet directamente. Los chequeos de salud se aplican a los FIPs privados y públicos respaldados por NIC. Las direcciones compartidas de varios miembros se siguen administrando a través de grupos de instancias; el extremo de conexión de interfaz manual toma un miembro. Abra una dirección no adjunta y elija **Attach**, luego elija la NIC bajo **Interface** y confirme con **Attach floating IP**. La misma acción se realiza en la propia NIC, como **Attach floating IP** en **Networking → Interfaces**. `POST /v1/floating-ips/{floating_ip_id}/attach` con `interface` (un UUID de interfaz o CRN anidado) y `address_id` (el ID de la dirección NIC correspondiente). ```bash theme={null} basaltic network floating-ip attach \ --interface --address-id ``` ```go theme={null} fip, err := network.New(cfg).AttachFloatingIP(ctx, floatingIPID, &network.AttachFloatingIPRequest{Interface: interfaceID, AddressID: addressID}) ``` Volver a conectar a una NIC que ya lo tiene es un éxito sin operación. Se deniega cuando: * un FIP público carece de una ruta de pasarela de Internet predeterminada en su familia (`400`); * un FIP privado y una NIC de destino pertenecen a diferentes VPC (`400`); * La dirección de destino está ausente o pertenece a la otra familia (`400`); * la interfaz ya lleva una IP flotante diferente en la misma familia y visibilidad (`409`); * la dirección ya tiene un miembro, por lo que un segundo lo convertiría en una dirección de anycast (`409`, ver más abajo); * La dirección está enlazada a un recurso que posee sus propias vinculaciones, como un balanceador de carga o un grupo de instancias, adjúntela y desáctívela allí. La consola no ofrece **Attach** en tal dirección en absoluto: su interfaz **Attached interface** dice **Bound by another service**, o **No replica is serving it yet** para un grupo. Elija **Detach** en la página de la dirección, o **Detach floating IP** en la página de la NIC. Confirme con **Detach**. Los enlaces de pool y balanceador de carga deben ser administrados a través de sus propietarios. `POST /v1/floating-ips/{floating_ip_id}/detach`. El cuerpo es opcional: una IP flotante ordinaria tiene como máximo un miembro. Omita `interface` para borrar el enlace, o nombre su interfaz por UUID o CRN anidado. Se rechazan los nombres sin texto, las referencias nulas y vacías. ```bash theme={null} basaltic network floating-ip detach ``` ```go theme={null} fip, err := network.New(cfg).DetachFloatingIP(ctx, floatingIPID, &network.DetachFloatingIPRequest{}) ``` Es idempotente. Al separar una dirección ya separada o nombrar una NIC que no es miembro, se devuelve `200` sin cambios en la fila. **Release floating IP**, en la pestaña **Settings** de la dirección. `DELETE /v1/floating-ips/{floating_ip_id}` ```bash theme={null} basaltic network floating-ip delete ``` ```go theme={null} err := network.New(cfg).DeleteFloatingIP(ctx, floatingIPID) ``` De cualquier manera, la dirección va de vuelta a la agrupación. Se rechaza con `409` mientras todavía está adjunta, o mientras pertenece a un grupo de instancias. Desconecta primero. ## Lectura de las encuadernaciones `attached_to` identifica al propietario del archivo adjunto por su CRN canónico. Es `null` solo cuando la dirección no está adjunta. Una vinculación de interfaz nombra el CRN de la interfaz anidada; una vinculación de grupo o balanceador de carga nombra ese recurso. Un grupo vacío todavía posee su dirección: `members: []` no significa que sea libre de adjuntar o liberar. Administre los enlaces de grupo a través de los [puntos finales de grupo](/es/compute/instance-pools#one-address-for-the-whole-pool). `members` El nombre de la propiedad describe las vinculaciones actuales, no la propiedad. `interface`, `address_id`, `health`, `reason` y `created_at`. El sistema integrado `interface` contiene `id`, `crn` y un nullable `instance` Resumen (`id`, `crn`, `name`Una interfaz sin una instancia propietaria tiene una instancia de propiedad. `instance: null`. Los miembros del balanceador de carga tienen `interface: null`; use el CRN del propietario de nivel superior para identificar el balanceador de carga.Compruebe si hay null antes de seguir cualquier resumen. Estos extractos de `GET /v1/floating-ips/{floating_ip_id}` ilustran los campos de adjuntos dentro de `floating_ip`; otros campos se omiten. Una interfaz ordinaria de enlace: ```json theme={null} { "attached_to": "crn:network:sa-saopaulo-1:my-account:vpc/prod/subnet/public/interface/eth0", "members": [{ "interface": { "id": "b9e4c7a2-1f8d-4a3b-9c6e-2d5a8b1f4c7e", "crn": "crn:network:sa-saopaulo-1:my-account:vpc/prod/subnet/public/interface/eth0", "instance": { "id": "550e8400-e29b-41d4-a716-446655440000", "crn": "crn:compute:sa-saopaulo-1:my-account:instance/web", "name": "web" } }, "health": "unknown", "reason": "unprobed", "created_at": "2026-09-01T12:00:00Z" }] } ``` Un grupo sin miembros actuales conserva su propiedad: ```json theme={null} { "attached_to": "crn:compute:sa-saopaulo-1:my-account:instance-pool/web", "members": [] } ``` A medida que se unen las réplicas, los `members` del grupo contienen la misma interfaz incrustada y los mismos resúmenes de instancias que un enlace ordinario. El propietario sigue siendo la agrupación CRN. Una dirección no adjunta: ```json theme={null} {"attached_to": null, "members": []} ``` Un enlace de balanceador de carga: ```json theme={null} { "attached_to": "crn:loadbalancer:sa-saopaulo-1:my-account:load-balancer/web", "members": [{ "interface": null, "health": "healthy", "reason": "passing", "created_at": "2026-09-01T12:00:00Z" }] } ``` ### Filtrar por propietario del accesorio Pasa un CRN exacto canónico a `attached_to` en `GET /v1/floating-ips`. Por ejemplo, esto enumera las direcciones de un grupo incluso cuando el grupo no tiene miembros: ```http theme={null} GET /v1/floating-ips?attached_to=crn:compute:sa-saopaulo-1:my-account:instance-pool/web&limit=50 ``` El filtro se aplica antes de la paginación y se interseca con otros filtros. Mientras `meta.has_more` es true, pasa `meta.marker` como `marker` en la siguiente petición, preservando `attached_to` y los otros filtros. Un CRN mal formado, un valor vacío o un CRN de interfaz plana devuelve `400`. Un CRN bien formado para otra cuenta, región o tipo de recurso no compatible devuelve una página vacía. El filtro no acepta UUIDs, nombres desnudos, o `null` para seleccionar direcciones libres; en su lugar, lista las direcciones y selecciona aquellas cuya `attached_to` es null. Con la CLI liberada, use el comando singular canónico y `--all` para recorrer todas las páginas coincidentes: ```bash theme={null} basaltic network floating-ip list --attached-to 'crn:compute:sa-saopaulo-1:my-account:instance-pool/web' --all ``` Con el SDK de Go, pase el mismo filtro a `ListFloatingIPs`: ```go theme={null} page, err := network.New(cfg).ListFloatingIPs(ctx, &network.ListFloatingIPsParams{ AttachedTo: "crn:compute:sa-saopaulo-1:my-account:instance-pool/web", }) ``` Esto devuelve una página. Preserve `AttachedTo` al establecer `Marker` para la siguiente página; alternativamente, el iterador `ListFloatingIPsAll` del SDK recorre todas las páginas por usted. El SDK representa JSON `attached_to: null` como una cadena vacía `AttachedTo`. ### Comprender la salud de los miembros | Estado | Significado | ¿Recibe tráfico? | | - | - | - | | `unknown` | No hay ninguna comprobación en ejecución; los miembros manuales ordinarios sin una comprobación de estado usan este estado. | Sí | | `healthy` | El invitado está en funcionamiento y cualquier comprobación de preparación configurada pasa. | Sí | | `unhealthy` | La instancia todavía no ha confirmado que está activa o una comprobación de preparación está fallando. | No | `reason` explica el estado: `unprobed` significa que no hay ninguna comprobación; `booting`, que la instancia todavía no ha confirmado que está activa; `probe_failed`, que una comprobación configurada está fallando; y `passing`, que la instancia está activa y supera las comprobaciones configuradas. Un miembro sin un estado saludable permanece en `members`; formar parte del grupo no significa estar preparado para recibir tráfico. Sin `health_check`, el estado saludable solo confirma que el sistema de la instancia está activo, no que la aplicación esté lista. Consulta [la guía de diagnóstico](/es/networking/troubleshooting#attachment-and-health-fields). ## Una dirección frente a varias instancias Una dirección con más de un miembro es una dirección anycast, y solo un [instance pool](/es/compute/instance-pools) puede ser propietario de una. La conexión de una segunda interfaz a mano se rechaza con `409`. Un grupo mantiene la membresía al mismo ritmo que crece. Todas las réplicas activas pueden unirse, incluidas las réplicas que comparten un host; la ubicación afecta a la capacidad y la resiliencia, no a si un miembro puede recibir tráfico. Los miembros que aún están arrancando pueden aparecer en la lista como no saludables antes de recibir tráfico. Abra el grupo en **Compute → Instance pools**, vaya a su pestaña **Floating IPs** y elija **Attach floating IP**. Separación es la acción **Detach floating IP** de la fila en esa misma pestaña. La página propia de la dirección no le permitirá hacer esto — una dirección que tiene un grupo no ofrece ningún botón **Attach**, y su interfaz **Attached interface** dice **No replica is serving it yet** hasta que una réplica la recoja. Use **Attachment owner** para abrir el grupo propietario o el balanceador de carga; si no se puede resolver el propietario, su CRN permanece visible. La pestaña **Interfaces** muestra identidades de miembros incrustadas, **Health** y **Reason**, sin controles de miembros manuales. Una agrupación vacía permanece unida. ```bash theme={null} POST /v1/instance-pools/{pool_id}/floating-ips { "floating_ip": "" } DELETE /v1/instance-pools/{pool_id}/floating-ips/{floating_ip_id} ``` ```bash theme={null} basaltic compute instance-pool attach-floating-ip \ --floating-ip basaltic compute instance-pool detach-floating-ip ``` ```go theme={null} c := compute.New(cfg) fip, err := c.AttachInstancePoolFloatingIP(ctx, poolID, &compute.InstancePoolFloatingIPAttachRequest{FloatingIP: floatingIPID}) err = c.DetachInstancePoolFloatingIP(ctx, poolID, floatingIPID) ``` Con varios miembros sanos, las nuevas conexiones se distribuyen entre ellos. Las direcciones de grupos privados permanecen dentro de su VPC. Las direcciones de grupo público requieren enrutamiento de Internet en su familia seleccionada. Las conexiones ya establecidas con un miembro no se migran cuando ese miembro desaparece. Una dirección compartida no termina TLS ni enruta solicitudes HTTP. Sin un `health_check` configurado, la salud del miembro indica solo si el sistema de la instancia está activo. Las conexiones en curso a un miembro que se va terminan en lugar de moverse. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.