Automating GCP External IP Reservation Upon Instance Creation

Question

Pulumi · Accepted Answer

To automate the reservation of an external IP address on Google Cloud Platform (GCP) and then use that IP to provision a compute instance, we'll leverage two types of resources:

1. **`google-native.compute/v1.Address`**: This is the resource that represents a reserved IP address within GCP. By creating this resource, we are reserving the external IP address that can be used for the instances and other resources across the GCP project.

2. **`google-native.compute/v1.Instance`**: This resource represents a compute instance within GCP. When creating this instance, we can reference the reserved IP address to ensure that it is associated with this new VM instance.

Here's a program written in TypeScript that you can use with Pulumi to set up a GCP compute instance with a reserved external IP address:

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

// Reserve a static IP address
const staticIp = new gcp.compute.Address("staticIp", {
    // You can choose any name
    name: "static-ip",
    // Optional: you may specify the region, if not, it will use the project's default region
});

// Creating an instance that uses the reserved static IP
const instance = new gcp.compute.Instance("instance", {
    // The instance needs a machine type, select the one that suits your needs
    machineType: "f1-micro",
    // Use the default image for the instance
    bootDisk: {
        initializeParams: {
            image: "debian-cloud/debian-9"
        }
    },
    // Set the network interface to use the static IP
    networkInterfaces: [{
        network: "default",
        accessConfigs: [{
            natIp: staticIp.address,
        }],
    }],
    //... you can specify additional properties for your instance
});

// Exporting the IP address and Instance Name to use outside our pulumi application
export const ipAddress = staticIp.address;
export const instanceName = instance.name;
```

In this Pulumi program, we start by creating a reserved IP address with `gcp.compute.Address`. Then, we instantiate a GCP compute instance with the reserved IP by using `gcp.compute.Instance` and passing the address to its `accessConfigs` attribute under the `networkInterfaces` property. Please note that this code sets up the most basic compute instance with default settings, such as using a `f1-micro` machine type and a Debian image. You can adjust these parameters based on your specific requirements.

You'll need to have Pulumi installed and configured for use with GCP in your environment to run this program. Also ensure that you've selected the correct GCP project and have the necessary permissions to create and modify these resources.

Save this code in a file named `index.ts`, for example. Be sure to have all dependencies installed by running `npm install @pulumi/pulumi @pulumi/gcp`. Then, simply run `pulumi up` to execute your program and create your resources in the cloud.

After running the program, the reserved IP address and the instance name will be printed out as stack outputs, which you can utilize in other infrastructure or applications as needed.