Automating F5 BIG-IP LTM pool member addition/removal via Auto Scaling

Question

Pulumi · Accepted Answer

To automate the addition and removal of pool members in an F5 BIG-IP Local Traffic Manager (LTM) using AWS Auto Scaling, you would typically set up an Auto Scaling Group (ASG) that defines the desired capacity and scaling policies for your instances. These policies would be based on triggers like CPU utilization or network load, and when a scaling event occurs, AWS Auto Scaling automatically adjusts the number of instances in the pool.

As instances are added to or removed from the ASG, lifecycle hooks can be used to register or deregister instances with the F5 BIG-IP LTM. You might also use AWS Lambda functions triggered by Auto Scaling lifecycle events to interact with the BIG-IP API for instance registration and deregistration.

The resources you will typically use include:

- `aws.autoscaling.Group`: To create and manage an Auto Scaling group that launches or terminates EC2 instances as demand on your application changes.
  
- `aws.autoscaling.Attachment`: To associate the Auto Scaling group with an existing load balancer so that the traffic is distributed to the instances within the ASG.

- `aws.autoscaling.Policy`: To define scaling policies that automatically adjust the size of your ASG when specific conditions are met.

- `aws.autoscaling.LifecycleHook`: To add lifecycle hooks to your ASG, which can be used to perform custom actions by pausing instances as an Auto Scaling group launches or terminates them.

Below is a TypeScript program using Pulumi for setting up such an environment:

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

// Create an Auto Scaling Group to manage EC2 instances
const autoScalingGroup = new aws.autoscaling.Group("asg", {
    maxSize: 5,
    minSize: 1,
    vpcZoneIdentifiers: ["subnet-xxxxxxxx"], // replace with your actual subnet
    // Associate your launch configuration, launch template or mixed instances policy
});

// Attach the ASG to an existing load balancer (this could be your F5 BIG-IP LTM)
const attachToElb = new aws.autoscaling.Attachment("attachToElb", {
    autoscalingGroupName: autoScalingGroup.name,
    lbTargetGroupArn: "arn:aws:elasticloadbalancing:REGION:ACCOUNT-ID:loadbalancer/app/LB-NAME/LB-ID" // replace with your actual target group ARN
});

// Define a scaling policy for the ASG based on CPU utilization
const scaleUpPolicy = new aws.autoscaling.Policy("scaleUp", {
    autoscalingGroupName: autoScalingGroup.name,
    adjustmentType: "ChangeInCapacity",
    scalingAdjustment: 2,
    cooldown: 300,
});

// Define a lifecycle hook to perform custom actions, such as registering/deregistering with BIG-IP
const lifecycleHook = new aws.autoscaling.LifecycleHook("lifecycleHook", {
    autoscalingGroupName: autoScalingGroup.name,
    lifecycleTransition: "autoscaling:EC2_INSTANCE_LAUNCHING", // or "autoscaling:EC2_INSTANCE_TERMINATING"
    notificationTargetARN: "arn:aws:sqs:REGION:ACCOUNT-ID:SQS-QUEUE-NAME", // replace with your actual SQS queue ARN
    roleArn: "arn:aws:iam::ACCOUNT-ID:role/AUTOSCALING_LIFECYCLE_HOOK_ROLE", // replace with your actual IAM role ARN
    notificationMetadata: JSON.stringify({ "action": "register" }), // the metadata information to provide to the notification target
});

// Add more lifecycle hooks as required for different actions
// ...

export const asgName = autoScalingGroup.name;
export const scalingPolicyArn = scaleUpPolicy.arn;
export const lifecycleHookName = lifecycleHook.name;
```

### Explanation:

- We start by importing the `aws` module from Pulumi's AWS SDK.
- Next, we create an Auto Scaling group with the `aws.autoscaling.Group` resource. You must replace `"subnet-xxxxxxxx"` with your actual subnet ID.
- We then attach this Auto Scaling group to a load balancer target group, which in this case would be the F5 BIG-IP LTM. The `aws.autoscaling.Attachment` resource is used for this.
- A scaling policy is defined with `aws.autoscaling.Policy`, which will control how the Auto Scaling Group responds to changes in demand. In this example, the group scales up by adding two instances when triggered.
- The `aws.autoscaling.LifecycleHook` resource is used to add a lifecycle hook to the Auto Scaling Group. The hook specified here will trigger an action when instances are launching. You need to replace the ARNs with ones that correspond to your actual AWS resources.
- Finally, we export the names and ARNs of the created resources so we can easily reference them.

### What's Next?

You might enhance this code further by:

- Specifying the launch configuration or launch template that determines the EC2 instance properties such as instance type, AMI, key pairs, security groups, etc.
- Adding additional lifecycle hooks for different actions like instance termination.
- Writing the custom logic (potentially an AWS Lambda function) that will receive lifecycle hook notifications and perform registration/deregistration with the BIG-IP LTM API.
- Adding error handling and logging in the lifecycle functions for better operational management.
- Configuring security groups, IAM roles, and permissions properly to make sure that the Auto Scaling Group and AWS Lambda functions can interact securely with the BIG-IP LTM.

Please make sure you have the appropriate permissions and configurations applied in your cloud environment before running this Pulumi program. Adjust the properties of each resource according to your setup requirements.