How to set up SonarQube on AWS Fargate with PostgreSQL RDS?

Question

Pulumi · Accepted Answer

To setup SonarQube on AWS Fargate with PostgreSQL RDS, you can use Pulumi as below.

First, let's import the AWS sdk for JavaScript and create a new Pulumi project:

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

We will start by creating a VPC (Virtual Private Cloud) and a security group which allows ingress on ports 9000 (for accessing the SonarQube dashboard) and 5432 (for connecting to the PostgreSQL database).

```typescript
// Create a new VPC for our Fargate containers
const vpc = new awsx.ec2.Vpc("vpc", { subnets: [{type: 'public'}] });

// Create a security group
const securityGroup = new aws.ec2.SecurityGroup("securityGroup", {
    vpcId: vpc.id,
    ingress: [
        { protocol: "tcp", fromPort: 9000, toPort: 9000, cidrBlocks: ["0.0.0.0/0"] }, // SonarQube dashboard
        { protocol: "tcp", fromPort: 5432, toPort: 5432, cidrBlocks: ["0.0.0.0/0"] }, // PostgreSQL
    ],
});
```

Next, let's set up PostgreSQL RDS instance. We will use the `aws.rds.Instance` class. We will create a `dbSubnetGroup` and a `dbParameterGroup` for the instance.

```typescript
// Create a DB Subnet Group
const dbSubnetGroup = new aws.rds.SubnetGroup("dbsubnet", {
    subnetIds: vpc.publicSubnetIds,
});

// Create a DB Parameter Group
const dbParameterGroup = new aws.rds.ParameterGroup('paramgroup', {
    family: 'postgres12'
});

// Create an RDS instance
const dbInstance = new aws.rds.Instance("dbInstance", {
    engine: "postgres",
    instanceClass: "db.t3.micro",
    allocatedStorage: 20,
    name: "mydb",
    username: "foo",
    password: "bar",
    dbSubnetGroupName: dbSubnetGroup.name,
    parameterGroupName: dbParameterGroup.name,
    vpcSecurityGroupIds: [securityGroup.id],
    skipFinalSnapshot: true,
});
```

Now we will create an ECS cluster and a Fargate task definition. The task definition specifies the Docker image to be used and the environment variables to be passed.

```typescript
// Create an ECS cluster
const cluster = new awsx.ecs.Cluster("cluster", { vpc });

// Create a task definition
const taskDefinition = new awsx.ecs.FargateTaskDefinition("taskDefinition", {
    containers: {
        sonarqube: {
            image: "sonarqube:latest",
            portMappings: [{ containerPort: 9000 }],
            environment: [
                { name: "SONARQUBE_JDBC_USERNAME", value: dbInstance.username },
                { name: "SONARQUBE_JDBC_PASSWORD", value: dbInstance.password },
                { name: "SONARQUBE_JDBC_URL", value: pulumi.interpolate `jdbc:postgresql://${dbInstance.endpoint}/sonar` },
            ],
        },
    },
});
```

Finally, we will create a Fargate service. This will run our task definition on the ECS cluster and use a public load balancer to expose the SonarQube dashboard on port 9000.

```typescript
// Create a Fargate service
const service = new awsx.ecs.FargateService("service", {
    cluster,
    taskDefinition,
    assignPublicIp: true,
    securityGroups: [securityGroup.id],
    subnets: vpc.publicSubnetIds,
    desiredCount: 1,
}, { dependsOn: dbInstance });

// Export the URL of the load balancer
export const url = service.loadBalancer.endpoint;
```

The `dependsOn` option makes sure that the Fargate service is not created until the RDS instance is available.

At the end, we export the URL of the load balancer. This is the URL on which the SonarQube dashboard will be accessible.

This setup should be capable of running SonarQube on AWS Fargate with a PostgreSQL RDS instance.