Can you explain the process of integrating Mailgun with Google Cloud Functions in TypeScript

Question

Pulumi · Accepted Answer

Certainly! Integrating Mailgun with Google Cloud Functions involves creating a cloud function that will interact with the Mailgun API to send emails when triggered. We'll go through the process step-by-step.

### Pre-requisites:
- You need a Mailgun account with a domain set up and API keys for authentication.
- You should have the `gcp` and `@pulumi/google-native` packages installed for your Pulumi project.
- You'll require `node-fetch` or a similar HTTP client library installed to make API requests from within the cloud function.

### Steps:
1. **Create a Google Cloud Function:** This will handle the logic for sending emails using Mailgun.
2. **Set up Environment Variables:** Store the Mailgun API key and domain as environment variables to be used securely within the cloud function.
3. **Write the Cloud Function Code:** This is where you implement the functionality to send emails with Mailgun.
4. **Deploy the Function with Pulumi:** Leverage Pulumi to deploy your cloud function and the environment configuration.

Let's look at the Pulumi program written in TypeScript to accomplish this:

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

// Read the content of the index.js file that will contain our Cloud Function logic
const indexPath = `./index.js`;
if (!fs.existsSync(indexPath)) {
    throw new Error("The `index.js` file must exist to deploy this Cloud Function");
}
const indexJs = fs.readFileSync(indexPath).toString();

// Define our Google Cloud Function resource
const mailgunFunction = new gcp.cloudfunctions.Function("send-email-function", {
    runtime: "nodejs14", // specify the runtime, Node.js in this case
    region: "us-central1", // define the region where function will be deployed
    entryPoint: "sendEmail", // this is the name of the exported function in your .js file
    triggerHttp: true, // we make it an HTTP-triggered cloud function
    sourceArchiveBucket: new gcp.storage.Bucket("source-archive-bucket", {}).name, // Bucket to store the source code
    sourceArchiveObject: new gcp.storage.BucketObject("index.js", { // Object that points to the Cloud Function code
        bucket: new gcp.storage.Bucket("source"),
        source: new pulumi.asset.FileAsset(indexPath), // Read the source code from the local path
    }).name,
    environmentVariables: { // setting up environment variables
        "MAILGUN_API_KEY": pulumi.Config.require("mailgunApiKey"), // Mailgun API key
        "MAILGUN_DOMAIN": pulumi.Config.require("mailgunDomain"), // Mailgun Domain
    },
});

// Output the trigger URL so we know where to send requests to invoke our function
export const functionUrl = mailgunFunction.httpsTriggerUrl;

// The index.js file should be defined like this:
// exports.sendEmail = (req, res) => {
//   // Here you will use the Mailgun API to send an email
//   // Use the environment variables to authenticate and construct your API request
// };
```

This Pulumi program first reads the contents of the `index.js` file, which should contain the JavaScript code for the cloud function. This file must define an exported function named `sendEmail` that encapsulates the logic for sending out an email via Mailgun.

In the Google Cloud Function resource (`gcp.cloudfunctions.Function`), we specify several important properties such as the runtime, region, entry point, and HTTP trigger configuration. We also set up a new GCS bucket to store our function's code and create a bucket object that points to the `index.js` file.

Moreover, we define two environment variables: `MAILGUN_API_KEY` and `MAILGUN_DOMAIN` — these are required for authenticating with the Mailgun API. You should ensure that these values are stored in your Pulumi configuration using `pulumi config set mailgunApiKey YOUR_MAILGUN_API_KEY` and `pulumi config set mailgunDomain YOUR_MAILGUN_DOMAIN`.

When you run `pulumi up`, Pulumi will deploy this cloud function and output the trigger URL, which is the endpoint you can use to trigger the function (usually via an HTTP request).

Remember to replace `index.js` with your actual cloud function code that uses the Node `fetch` API or a library like `axios` to make POST requests to the Mailgun API for sending emails. The `environmentVariables` will be accessible in your cloud function so you can use them to authenticate against the Mailgun API.