Creating Quick Connect buttons for commonly used destinations

Question

Pulumi · Accepted Answer

To create a Quick Connect feature, which typically allows users to rapidly access commonly used services or destinations, you might want to provision infrastructure that can trigger specific actions or connect to services. One way to implement this using cloud infrastructure is to set up serverless functions that perform the necessary actions whenever they are triggered.

Assuming you want to create Quick Connect buttons for AWS services, you can use AWS Lambda functions for the backend, triggered by API Gateway endpoints. This setup allows you to create HTTP endpoints (effectively "buttons") that, when accessed, will execute predefined actions such as connecting to a database, sending a notification, or starting a virtual machine.

Below is a Pulumi program written in TypeScript that sets up an AWS API Gateway with a single Lambda function. You can replicate the pattern for more destinations by adding more Lambda functions and routes.

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

// Create an AWS Lambda function that will be our "destination" action.
const quickConnectLambda = new aws.lambda.Function("quickConnectLambda", {
    runtime: aws.lambda.NodeJS12dXRuntime, // choose the appropriate runtime
    code: new pulumi.asset.AssetArchive({
        // The directory containing your Lambda code, zipped
        ".": new pulumi.asset.FileArchive("./path-to-lambda-code"),
    }),
    handler: "index.handler", // your handler path, standard is index.handler
    role: lambdaRole.arn // the ARN for the IAM role with Lambda execution permissions
});

// Create a new role for the Lambda function.
const lambdaRole = new aws.iam.Role("lambdaRole", {
    assumeRolePolicy: {
        Version: "2012-10-17",
        Statement: [{
            Action: "sts:AssumeRole",
            Effect: "Allow",
            Principal: {
                Service: "lambda.amazonaws.com",
            },
        }],
    },
});

// Attach the AWS Lambda Basic Execution Role to the Lambda function.
const lambdaRolePolicyAttachment = new aws.iam.RolePolicyAttachment("lambdaRolePolicyAttachment", {
    role: lambdaRole,
    policyArn: "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole",
});

// Create an API Gateway to trigger the Lambda function.
const api = new aws.apigatewayv2.Api("httpApi", {
    protocolType: "HTTP",
});

// Create a default stage for the API.
const stage = new aws.apigatewayv2.Stage("httpApiStage", {
    apiId: api.id,
    name: "$default",
    autoDeploy: true,
});

// Create an integration between the API Gateway and the Lambda function.
const integration = new aws.apigatewayv2.Integration("httpApiIntegration", {
    apiId: api.id,
    integrationType: "AWS_PROXY",
    integrationUri: quickConnectLambda.arn,
    payloadFormatVersion: "2.0",
});

// Create a route for the API Gateway.
const route = new aws.apigatewayv2.Route("httpApiRoute", {
    apiId: api.id,
    routeKey: "GET /quickconnect",
    target: pulumi.interpolate`integrations/${integration.id}`,
});

// Grant the API Gateway permission to invoke the Lambda function.
const lambdaPermission = new aws.lambda.Permission("apiGatewayLambda", {
    action: "lambda:InvokeFunction",
    function: quickConnectLambda.name,
    principal: "apigateway.amazonaws.com",
    sourceArn: pulumi.interpolate`${api.executionArn}/*/*`,
});

// Export the URL of the API Gateway to access the Quick Connect button.
export const quickConnectUrl = pulumi.interpolate`${api.apiEndpoint}/${stage.name}/quickconnect`;

```

This Pulumi program does the following:
1. Sets up an AWS Lambda function, which is the destination or action for the Quick Connect button.
2. Creates an IAM role with the necessary permissions for the Lambda function to run.
3. Defines an AWS API Gateway with a default stage.
4. Creates an integration that connects the API Gateway to the Lambda function.
5. Sets up a route that activates the Lambda function when visited. Here, "GET /quickconnect" could represent a "Quick Connect" endpoint.
6. Grants permission to the API Gateway to trigger the Lambda function.

This is a simplified example where the Lambda function acts as a placeholder for any action you want to perform. You can modify the Lambda function to connect to other AWS resources or perform different activities as needed. The last line of the program exports the URL that represents the Quick Connect button, which you can distribute or embed as needed.

Remember to replace `"./path-to-lambda-code"` with the actual path to the ZIP package containing your Lambda function code and update the handler if necessary. The IAM role should have the necessary permissions for whichever specific actions the Lambda function is supposed to perform on your AWS resources.