Enforcing automatic or manual failover policies for high availability

Question

Pulumi · Accepted Answer

High availability is a critical aspect of cloud infrastructure, ensuring that services remain available and reliable even in the event of hardware failures, maintenance, or other disruptions. Pulumi allows us to define infrastructure as code that can include high-availability configurations.

To accomplish high availability with automatic or manual failover policies, you would typically make use of services that offer built-in redundancy, replication, or failover mechanisms. For instance, in cloud environments like AWS, Azure, or Google Cloud, you can configure databases, virtual machines, and Kubernetes clusters to automatically failover to standby resources in different zones or regions.

Below is a TypeScript program using Pulumi to set up an Azure SQL Database with a high availability configuration. In this program, we'll define an elastic pool which is a collection of databases with a shared set of resources, such as CPU and memory. The `zoneRedundant` property will be set to `true` to enable high availability. The pool automatically handles failover without any manual intervention.

Before diving into the code, make sure you have the following prerequisites:

1. Pulumi CLI installed and set up.
2. Active Azure account and credentials configured for use with Pulumi.
3. Appropriate privileges to create resources in your Azure subscription.

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure-native";

// Define a resource group where all our resources will live
const resourceGroup = new azure.resources.ResourceGroup("highAvailabilityResourceGroup", {
    // The location property is set to a region that supports zone redundancy
    // Refer to Azure's regional availability
    location: "East US", // Adjust the location as per your requirement
});

// Create an Azure SQL server that will host our elastic pool and databases
const sqlServer = new azure.sql.Server("sqlServer", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    version: "12.0", // Use a suitable version for your needs
    administratorLogin: "sqladmin",
    administratorLoginPassword: "ComplexPassword!", // Replace with a secure password
});

// Define an Elastic Pool with zone redundancy enabled
const highAvailabilityElasticPool = new azure.sql.ElasticPool("highAvailabilityElasticPool", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    serverName: sqlServer.name,
    zoneRedundant: true, // Enable zone redundancy for high availability
    sku: {
        name: "GP_Gen5", // General Purpose, adjust based on your requirements
        tier: "GeneralPurpose",
        family: "Gen5", // Adjust the compute generation as needed
        capacity: 2, // Set the DTU or vCores count
    },
    // Additional properties such as 'licenseType', 'minCapacity', 'maxSizeBytes' can be set as per requirements
});

// Export the SQL server's fully qualified domain name to access it later
export const sqlServerFqdn = sqlServer.fullyQualifiedDomainName;

```

This Pulumi program will create an Azure SQL Server and an Elastic Pool with zone redundancy enabled – this means that the resources will be distributed across multiple availability zones, ensuring that if one zone goes down, the others can pick up the load.

Please remember to replace the `administratorLoginPassword` with a strong, unique password. Also, the `location` should be chosen based on where you need your resources to be deployed, and it must support the availability zones feature.

After running this code with `pulumi up`, Pulumi will perform the declared changes to achieve the desired state of the infrastructure: an Azure SQL Elastic Pool configured for high availability.

When designing for high availability, consider all components of your system and ensure that they are deployed across multiple locations where possible and applicable.

Remember to check the Pulumi documentation for [azure-native.sql.ElasticPool](https://www.pulumi.com/registry/packages/azure-native/api-docs/sql/elasticpool/) for further information on the properties and configurations available for the elastic pools in Azure SQL Database.