Setting up external gateway for OpenStack virtual networks

Question

Pulumi · Accepted Answer

To set up an external gateway for OpenStack virtual networks using Pulumi, you would leverage the OpenStack provider, which allows you to interact with your OpenStack cloud. The following program in TypeScript provides a hypothetical setup that would help you understand the concepts. We will create a network and a subnet, then we'll set up a router and attach a gateway to the public network, which is typically external and provides access to the outside world.

Ensure you have the OpenStack provider configured with the necessary credentials to interact with your OpenStack deployment.

Here's what you'll need to do:

1. Create a network: This network acts as a container for all your OpenStack networking components.
2. Create a subnet: The subnet allows you to define IP address ranges, gateways, DNS servers, and other settings.
3. Create a router: This router will be used to route traffic between your virtual network and the external network.
4. Set the router gateway: By setting the external network as the router's gateway, you create the point of exit and entry for the network traffic.

Let's proceed with the Pulumi TypeScript code:

```typescript
import * as openstack from "@pulumi/openstack";

// Create a Network
const net = new openstack.networking.Network("my-network", {
  // Optionally, you can specify additional properties as needed.
  adminStateUp: true,
});

// Create a Subnet within the Network
const subnet = new openstack.networking.Subnet("my-subnet", {
  networkId: net.id,
  cidr: "192.168.199.0/24", // Example CIDR block
  ipVersion: 4,
  // Optionally, add DNS Servers, Allocation Pools, and other subnet configurations here.
});

// Create a Router
const router = new openstack.networking.Router("my-router", {
  // Under normal circumstances, you will not need to set `adminStateUp` to `true` as it is by default.
  adminStateUp: true,
});

// Create an external gateway for the router
const publicNet = openstack.networking.getNetwork({
  // You will need to replace this with the name or ID of your public/external network.
  name: "public",
});

publicNet.then(pubNet => {
  new openstack.networking.RouterInterface("router-interface", {
    routerId: router.id,
    subnetId: subnet.id,
  });

new openstack.networking.RouterGateway("router-gateway", {
    routerId: router.id,
    networkId: pubNet.id, // Assign the external network as the gateway
  });
});

// Export useful values
export const networkId = net.id;
export const subnetId = subnet.id;
export const routerId = router.id;
```

Here's what each part of the program does:

- We import the OpenStack package from Pulumi that allows us to create various OpenStack resources.
- Then we create a virtual network (`my-network`), a subnet (`my-subnet`), and a router (`my-router`). These resources are foundational pieces for any network setup on OpenStack.
- We then use the `getNetwork` function to retrieve the details of the public network. This is typically provided by the OpenStack setup and is needed to bridge our internal networking with the outside world.
- With the `RouterInterface` and `RouterGateway`, the router is now capable of directing traffic from within our internal network (`my-subnet`) to the global internet through the external `public` network. This act essentially establishes our external gateway.

Remember to replace placeholders like `public` with actual values that correspond to your OpenStack environment. This program assumes that you have a public network named "public" available on your OpenStack for establishing internet connectivity.

Run the above program with the Pulumi CLI to deploy the resources into your OpenStack environment. You can use `pulumi up` to create or update resources according to your Pulumi program and `pulumi destroy` to tear them down.

This is a foundational setup; your actual use case might include additional configurations, such as assigning floating IP addresses or setting up security groups and rules for finer access control. Pulumi's OpenStack provider offers resources to manage these aspects as well.