Using kubernetes rds.services.k8s.aws with awx.ansible.com

Question

Pulumi · Accepted Answer

To accomplish your goal of integrating AWS RDS with Kubernetes and managing it via AWX from Ansible, you'd need to follow these steps:

1. **Provision an Amazon RDS instance**: This would provide the relational database service for your application.
2. **Deploy your Kubernetes cluster**: Where your applications will run.
3. **Install AWX on your Kubernetes cluster**: AWX is the open-source version of Ansible Tower, which provides a web-based user interface, REST API, and task engine for Ansible.
4. **Configure AWX to manage the RDS instance**: AWX will need the necessary permissions and configurations to manage resources on AWS including the RDS instance.

The following TypeScript program uses Pulumi to create a Kubernetes cluster using Amazon EKS, sets up an RDS instance, and deploys AWX into the Kubernetes cluster:

```typescript
import * as aws from "@pulumi/aws";
import * as k8s from "@pulumi/kubernetes";
import * as pulumi from "@pulumi/pulumi";
import * as awsx from "@pulumi/awsx";
import * as eks from "@pulumi/eks";

// Create an AWS RDS instance
const dbSubnet = new aws.rds.SubnetGroup("db-subnet", {
    subnetIds: awsx.ec2.Vpc.getDefault().publicSubnetIds,
});

const db = new aws.rds.Instance("db", {
    allocatedStorage: 20,
    engine: "mysql",
    engineVersion: "5.7",
    instanceClass: "db.t2.micro",
    name: "mydb",
    parameterGroupName: "default.mysql5.7",
    password: "foobarbaz",
    skipFinalSnapshot: true,
    subnetGroupName: dbSubnet.name,
    username: "foo",
});

// Create an EKS cluster
const cluster = new eks.Cluster("cluster", {
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 2,
});

// Export the cluster's kubeconfig
export const kubeconfig = cluster.kubeconfig;

// Deploy the AWX operator (which will manage AWX deployment within Kubernetes)
const awxOperatorNamespace = new k8s.core.v1.Namespace("awx-operator-ns", {}, { provider: cluster.provider });

const awxOperatorChart = new k8s.helm.v3.Chart("awx-operator", {
    namespace: awxOperatorNamespace.metadata.name,
    chart: "awx-operator",
    fetchOpts: {
        // You can specify the version here with the `version: "x.y.z"` option
        repo: "https://operator-framework.github.io/community-operators/",
    },
}, { provider: cluster.provider });

// Deploy AWX using the operator
const awxNamespace = new k8s.core.v1.Namespace("awx-ns", {}, { provider: cluster.provider });

const awx = new k8s.apiextensions.CustomResource("awx", {
    apiVersion: "awx.ansible.com/v1beta1",
    kind: "AWX",
    metadata: {
        namespace: awxNamespace.metadata.name,
        name: "awx",
    },
    spec: {
        service_type: "NodePort",
        hostname: "awx.example.com",
    },
}, { provider: cluster.provider, dependsOn: awxOperatorChart });

// Output the RDS instance endpoint and the AWX service information
export const rdsEndpoint = db.endpoint;
export const awxService = awx.status;
```

### Detailed Explanation

**Creating an AWS RDS Instance**: A new RDS instance is created within a default VPC and subnet. It's configured with MySQL as the database engine.

**Creating an EKS Cluster**: A new Amazon EKS (Elastic Kubernetes Service) cluster is created with the specified instance configuration. The cluster will serve as a control plane to deploy the AWX application.

**Deploying AWX Operator**: Kubernetes Helm chart is used to deploy the AWX operator. The AWX operator is a Kubernetes operator which will handle the deployment of AWX on Kubernetes.

**Deploying AWX Custom Resource**: The AWX custom resource is a representation of the AWX application within Kubernetes. It is how you ask the AWX operator to deploy an instance of AWX within your cluster.

**Output Variables**: The endpoint of the RDS instance and the status of the AWX service are exported to easily access these resources after they have been provisioned.

Remember to replace placeholder values with actual values you wish to use, such as database credentials and the hostname for AWX. After provisioning, you would need to perform further configuration in AWX to connect it with the RDS database and manage it as per your requirements.