You need to create a reusable Pulumi component resource that provisions a 'Microservice' abstraction including an ECS Fargate service, ALB target group, Route53 record, and CloudWatch alarms. How do you design this component?

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

export interface MicroserviceArgs {
  image: pulumi.Input<string>;
  port: number;
  cpu?: number;
  memory?: number;
  desiredCount?: number;
  healthCheckPath?: string;
  environment?: Record<string, pulumi.Input<string>>;
  vpcId: pulumi.Input<string>;
  subnetIds: pulumi.Input<string>[];
  albListenerArn: pulumi.Input<string>;
  hostHeader: string;
  hostedZoneId: pulumi.Input<string>;
}

export class Microservice extends pulumi.ComponentResource {
  public readonly url: pulumi.Output<string>;
  public readonly serviceArn: pulumi.Output<string>;
  public readonly targetGroupArn: pulumi.Output<string>;

  constructor(name: string, args: MicroserviceArgs, opts?: pulumi.ComponentResourceOptions) {
    super("acme:platform:Microservice", name, {}, opts);

    const cpu = args.cpu || 256;
    const memory = args.memory || 512;
    const desiredCount = args.desiredCount || 2;
    const healthCheckPath = args.healthCheckPath || "/health";

    // Task Definition
    const taskDef = new aws.ecs.TaskDefinition(`${name}-task`, {
      family: name,
      networkMode: "awsvpc",
      requiresCompatibilities: ["FARGATE"],
      cpu: cpu.toString(),
      memory: memory.toString(),
      executionRoleArn: executionRole.arn,
      containerDefinitions: pulumi.output(args.image).apply(image => JSON.stringify([{
        name: name,
        image: image,
        portMappings: [{ containerPort: args.port }],
        environment: Object.entries(args.environment || {}).map(([k, v]) => ({ name: k, value: v })),
        logConfiguration: {
          logDriver: "awslogs",
          options: { "awslogs-group": `/ecs/${name}`, "awslogs-region": "us-east-1" },
        },
      }])),
    }, { parent: this });

    // Target Group
    const tg = new aws.lb.TargetGroup(`${name}-tg`, {
      port: args.port,
      protocol: "HTTP",
      vpcId: args.vpcId,
      targetType: "ip",
      healthCheck: { path: healthCheckPath, interval: 15 },
    }, { parent: this });

    // ALB Listener Rule
    new aws.lb.ListenerRule(`${name}-rule`, {
      listenerArn: args.albListenerArn,
      conditions: [{ hostHeader: { values: [args.hostHeader] } }],
      actions: [{ type: "forward", targetGroupArn: tg.arn }],
    }, { parent: this });

    // ECS Service
    const service = new aws.ecs.Service(`${name}-svc`, {
      cluster: clusterArn,
      taskDefinition: taskDef.arn,
      desiredCount: desiredCount,
      launchType: "FARGATE",
      networkConfiguration: {
        subnets: args.subnetIds,
        assignPublicIp: false,
      },
      loadBalancers: [{ targetGroupArn: tg.arn, containerName: name, containerPort: args.port }],
    }, { parent: this });

    // CloudWatch Alarm
    new aws.cloudwatch.MetricAlarm(`${name}-5xx-alarm`, {
      metricName: "HTTPCode_Target_5XX_Count",
      namespace: "AWS/ApplicationELB",
      statistic: "Sum",
      period: 60,
      evaluationPeriods: 3,
      threshold: 10,
      comparisonOperator: "GreaterThanThreshold",
      alarmActions: [snsTopicArn],
    }, { parent: this });

    this.url = pulumi.interpolate`https://${args.hostHeader}`;
    this.serviceArn = service.id;
    this.targetGroupArn = tg.arn;

    this.registerOutputs({ url: this.url, serviceArn: this.serviceArn });
  }
}

// Usage:
const orderService = new Microservice("order-service", {
  image: "123456789.dkr.ecr.us-east-1.amazonaws.com/order-service:v1.2.3",
  port: 8080,
  desiredCount: 3,
  hostHeader: "orders.api.acme.com",
  vpcId: infra.vpcId,
  subnetIds: infra.privateSubnetIds,
  albListenerArn: infra.albListenerArn,
  hostedZoneId: infra.hostedZoneId,
});