# yaml-language-server: $schema=https://raw.githubusercontent.com/pulumi/pulumi/master/pkg/codegen/schema/pulumi.json
---
name: metabase
types:
  metabase:index:Networking:
    description: The options for networking.
    type: object
    properties:
      ecsSubnetIds:
        description: The subnets to use for the Fargate task.
        type: array
        items:
          type: string
      dbSubnetIds:
        description: The subnets to use for the RDS instance.
        type: array
        items:
          type: string
      lbSubnetIds:
        description: The subnets to use for the load balancer.
        type: array
        items:
          type: string
  metabase:index:CustomDomain:
    description: Options for setting a custom domain.
    type: object
    properties:
      hostedZoneName:
        type: string
      domainName:
        type: string
resources:
  metabase:index:Metabase:
    description: |
      This resources provisions a container running Metabase on AWS ECS Fargate. By default
      the resource will run the service in the AWS Account's Default VPC unless a VPC is defined. This
      resource will also deploy the `latest` version of Metabase unless a version is supplied.

      You can provide specific subnets to host the Load Balancer, Database, and ECS Service, as well
      as provide a custom domain name for the service.

      {{% examples %}}
      ## Example Usage

      {{% example %}}
      ### Default

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

      const metabaseService = new metabase.Metabase("metabaseService", {});
      export const url = metabaseService.dnsName;
      ```

      ```python
      import pulumi
      import pulumi_metabase as metabase

      metabase_service = metabase.Metabase("metabaseService")
      pulumi.export("url", metabase_service.dns_name)
      ```

      ```go
      package main

      import (
        "github.com/pulumi/pulumi-metabase/sdk/go/metabase"
        "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
      )

      func main() {
        pulumi.Run(func(ctx *pulumi.Context) error {
          metabaseService, err := metabase.NewMetabase(ctx, "metabaseService", nil)
          if err != nil {
            return err
          }
          ctx.Export("url", metabaseService.DnsName)
          return nil
        })
      }
      ```

      ```csharp
      using Pulumi;
      using Metabase = Pulumi.Metabase;

      class MyStack : Stack
      {
          public MyStack()
          {
              var metabaseService = new Metabase.Metabase("metabaseService", new Metabase.MetabaseArgs
              {
              });
              this.Url = metabaseService.DnsName;
          }

          [Output("url")]
          public Output<string> Url { get; set; }
      }
      ```

      ```yaml
      name: metabase-yaml
      runtime: yaml
      resources:
          metabaseService:
              type: "metabase:index:Metabase"
      outputs:
          url: ${metabaseService.dnsName}
      ```
      {{ /example }}

      {{% example %}}
      ### Custom Domain & Networking

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

      const metabaseService = new metabase.Metabase("metabaseService", {
          vpcId: "vpc-123",
          networking: {
              ecsSubnetIds: [
                  "subnet-123",
                  "subnet-456",
              ],
              dbSubnetIds: [
                  "subnet-789",
                  "subnet-abc",
              ],
              lbSubnetIds: [
                  "subnet-def",
                  "subnet-ghi",
              ],
          },
          domain: {
              hostedZoneName: "example.com",
              domainName: "metabase.example.com",
          },
      });
      export const url = metabaseService.dnsName;
      ```

      ```python
      import pulumi
      import pulumi_metabase as metabase

      metabase_service = metabase.Metabase("metabaseService",
          vpc_id="vpc-123",
          networking=metabase.NetworkingArgs(
              ecs_subnet_ids=[
                  "subnet-123",
                  "subnet-456",
              ],
              db_subnet_ids=[
                  "subnet-789",
                  "subnet-abc",
              ],
              lb_subnet_ids=[
                  "subnet-def",
                  "subnet-ghi",
              ],
          ),
          domain=metabase.CustomDomainArgs(
              hosted_zone_name="example.com",
              domain_name="metabase.example.com",
          ))
      pulumi.export("url", metabase_service.dns_name)
      ```

      ```go
      package main

      import (
        "github.com/pulumi/pulumi-metabase/sdk/go/metabase"
        "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
      )

      func main() {
        pulumi.Run(func(ctx *pulumi.Context) error {
          metabaseService, err := metabase.NewMetabase(ctx, "metabaseService", &metabase.MetabaseArgs{
            VpcId: pulumi.String("vpc-123"),
            Networking: &metabase.NetworkingArgs{
              EcsSubnetIds: pulumi.StringArray{
                pulumi.String("subnet-123"),
                pulumi.String("subnet-456"),
              },
              DbSubnetIds: pulumi.StringArray{
                pulumi.String("subnet-789"),
                pulumi.String("subnet-abc"),
              },
              LbSubnetIds: pulumi.StringArray{
                pulumi.String("subnet-def"),
                pulumi.String("subnet-ghi"),
              },
            },
            Domain: &metabase.CustomDomainArgs{
              HostedZoneName: pulumi.String("example.com"),
              DomainName:     pulumi.String("metabase.example.com"),
            },
          })
          if err != nil {
            return err
          }
          ctx.Export("url", metabaseService.DnsName)
          return nil
        })
      }
      ```

      ```csharp
      using Pulumi;
      using Metabase = Pulumi.Metabase;

      class MyStack : Stack
      {
          public MyStack()
          {
              var metabaseService = new Metabase.Metabase("metabaseService", new Metabase.MetabaseArgs
              {
                  VpcId = "vpc-123",
                  Networking = new Metabase.Inputs.NetworkingArgs
                  {
                      EcsSubnetIds =
                      {
                          "subnet-123",
                          "subnet-456",
                      },
                      DbSubnetIds =
                      {
                          "subnet-789",
                          "subnet-abc",
                      },
                      LbSubnetIds =
                      {
                          "subnet-def",
                          "subnet-ghi",
                      },
                  },
                  Domain = new Metabase.Inputs.CustomDomainArgs
                  {
                      HostedZoneName = "example.com",
                      DomainName = "metabase.example.com",
                  },
              });
              this.Url = metabaseService.DnsName;
          }

          [Output("url")]
          public Output<string> Url { get; set; }
      }
      ```

      ```yaml
      name: metabase-yaml
      runtime: yaml
      resources:
          metabaseService:
              type: "metabase:index:Metabase"
              properties:
                  vpcId: "vpc-123"
                  networking:
                      ecsSubnetIds: [ "subnet-123", "subnet-456" ]
                      dbSubnetIds: [ "subnet-789", "subnet-abc" ]
                      lbSubnetIds: [ "subnet-def", "subnet-ghi" ]
                  domain:
                      hostedZoneName: "example.com"
                      domainName: "metabase.example.com"
      outputs:
          url: ${metabaseService.dnsName}
      ```
      {{ /example }}
      {{% examples %}}
    isComponent: true
    inputProperties:
      vpcId:
        type: string
        description: The VPC to use for the Metabase service. If left blank then the default VPC will be used.
      networking:
        description: Optionally provide specific subnet IDs to run the different resources of Metabase.
        $ref: "#/types/metabase:index:Networking"
      domain:
        description: Optionally provide a hosted zone and domain name for the Metabase service.
        $ref: "#/types/metabase:index:CustomDomain"
      metabaseVersion:
        description: The version of Metabase to run - used as a tag on the `metabase/metabase` Dockerhub image.
        type: string
    requiredInputs: []
    properties:
      dnsName:
        type: string
        description: The DNS name for the Metabase instance.
      securityGroupId:
        type: string
        description: The security group id for the Metabase instance.
    required:
      - dnsName
      - securityGroupId

language:
  csharp:
    packageReferences:
      Pulumi: 3.*
      Pulumi.Aws: 5.*
      Pulumi.Random: 4.*
  go:
    generateResourceContainerTypes: true
    importBasePath: github.com/pulumi/pulumi-metabase/sdk/go/metabase
  nodejs:
    dependencies:
      "@pulumi/aws": "^5.0.0"
      "@pulumi/random": "^4.0.0"
    devDependencies:
      typescript: "^3.7.0"
  python:
    requires:
      pulumi: ">=3.0.0,<4.0.0"
      pulumi-aws: ">=5.0.0,<6.0.0"
      pulumi-random: ">=4.0.0,<5.0.0"
