Start infra

[kevencript]

No description provided.

[github-actions]

Terraform Format and Style 🖌success

Terraform Initialization ⚙️success

Terraform Validation 🤖success

Validation Output

Warning: Deprecated Resource

  with module.superfluid_ecs_task.data.aws_subnet_ids.superfluid,
  on modules/ecs-task/service.tf line 23, in data "aws_subnet_ids" "superfluid":
  23: data "aws_subnet_ids" "superfluid" {

The aws_subnet_ids data source has been deprecated and will be removed in a
future version. Use the aws_subnets data source instead.
Success! The configuration is valid, but there were some validation warnings
as shown above.

Terraform Plan 📖success

Show Plan

terraform
module.superfluid_ecs.data.aws_availability_zones.available_zones: Reading...
module.superfluid_ecs.data.aws_availability_zones.available_zones: Read complete after 0s [id=us-east-1]

Terraform used the selected providers to generate the following execution
plan. Resource actions are indicated with the following symbols:
  + create
 <= read (data resources)

Terraform will perform the following actions:

  # module.superfluid_ecs.aws_ecs_cluster.superfluid_ecs_cluster_main will be created
  + resource "aws_ecs_cluster" "superfluid_ecs_cluster_main" {
      + arn                = (known after apply)
      + capacity_providers = [
          + "FARGATE",
          + "FARGATE_SPOT",
        ]
      + id                 = (known after apply)
      + name               = (known after apply)
      + tags               = {
          + "app:environment" = "production"
          + "app:name"        = "superfluid-sentinel"
        }
      + tags_all           = {
          + "app:environment" = "production"
          + "app:name"        = "superfluid-sentinel"
        }

      + default_capacity_provider_strategy {
          + base              = 0
          + capacity_provider = "FARGATE_SPOT"
          + weight            = 4
        }
      + default_capacity_provider_strategy {
          + base              = 1
          + capacity_provider = "FARGATE"
          + weight            = 1
        }

      + setting {
          + name  = "containerInsights"
          + value = "enabled"
        }
    }

  # module.superfluid_ecs.aws_eip.gateway[0] will be created
  + resource "aws_eip" "gateway" {
      + allocation_id        = (known after apply)
      + association_id       = (known after apply)
      + carrier_ip           = (known after apply)
      + customer_owned_ip    = (known after apply)
      + domain               = (known after apply)
      + id                   = (known after apply)
      + instance             = (known after apply)
      + network_border_group = (known after apply)
      + network_interface    = (known after apply)
      + private_dns          = (known after apply)
      + private_ip           = (known after apply)
      + public_dns           = (known after apply)
      + public_ip            = (known after apply)
      + public_ipv4_pool     = (known after apply)
      + tags_all             = (known after apply)
      + vpc                  = true
    }

  # module.superfluid_ecs.aws_eip.gateway[1] will be created
  + resource "aws_eip" "gateway" {
      + allocation_id        = (known after apply)
      + association_id       = (known after apply)
      + carrier_ip           = (known after apply)
      + customer_owned_ip    = (known after apply)
      + domain               = (known after apply)
      + id                   = (known after apply)
      + instance             = (known after apply)
      + network_border_group = (known after apply)
      + network_interface    = (known after apply)
      + private_dns          = (known after apply)
      + private_ip           = (known after apply)
      + public_dns           = (known after apply)
      + public_ip            = (known after apply)
      + public_ipv4_pool     = (known after apply)
      + tags_all             = (known after apply)
      + vpc                  = true
    }

  # module.superfluid_ecs.aws_internet_gateway.gateway will be created
  + resource "aws_internet_gateway" "gateway" {
      + arn      = (known after apply)
      + id       = (known after apply)
      + owner_id = (known after apply)
      + tags_all = (known after apply)
      + vpc_id   = (known after apply)
    }

  # module.superfluid_ecs.aws_nat_gateway.gateway[0] will be created
  + resource "aws_nat_gateway" "gateway" {
      + allocation_id        = (known after apply)
      + connectivity_type    = "public"
      + id                   = (known after apply)
      + network_interface_id = (known after apply)
      + private_ip           = (known after apply)
      + public_ip            = (known after apply)
      + subnet_id            = (known after apply)
      + tags_all             = (known after apply)
    }

  # module.superfluid_ecs.aws_nat_gateway.gateway[1] will be created
  + resource "aws_nat_gateway" "gateway" {
      + allocation_id        = (known after apply)
      + connectivity_type    = "public"
      + id                   = (known after apply)
      + network_interface_id = (known after apply)
      + private_ip           = (known after apply)
      + public_ip            = (known after apply)
      + subnet_id            = (known after apply)
      + tags_all             = (known after apply)
    }

  # module.superfluid_ecs.aws_route.internet_access will be created
  + resource "aws_route" "internet_access" {
      + destination_cidr_block = "0.0.0.0/0"
      + gateway_id             = (known after apply)
      + id                     = (known after apply)
      + instance_id            = (known after apply)
      + instance_owner_id      = (known after apply)
      + network_interface_id   = (known after apply)
      + origin                 = (known after apply)
      + route_table_id         = (known after apply)
      + state                  = (known after apply)
    }

  # module.superfluid_ecs.aws_route_table.private[0] will be created
  + resource "aws_route_table" "private" {
      + arn              = (known after apply)
      + id               = (known after apply)
      + owner_id         = (known after apply)
      + propagating_vgws = (known after apply)
      + route            = [
          + {
              + carrier_gateway_id         = ""
              + cidr_block                 = "0.0.0.0/0"
              + core_network_arn           = ""
              + destination_prefix_list_id = ""
              + egress_only_gateway_id     = ""
              + gateway_id                 = ""
              + instance_id                = ""
              + ipv6_cidr_block            = ""
              + local_gateway_id           = ""
              + nat_gateway_id             = (known after apply)
              + network_interface_id       = ""
              + transit_gateway_id         = ""
              + vpc_endpoint_id            = ""
              + vpc_peering_connection_id  = ""
            },
        ]
      + tags_all         = (known after apply)
      + vpc_id           = (known after apply)
    }

  # module.superfluid_ecs.aws_route_table.private[1] will be created
  + resource "aws_route_table" "private" {
      + arn              = (known after apply)
      + id               = (known after apply)
      + owner_id         = (known after apply)
      + propagating_vgws = (known after apply)
      + route            = [
          + {
              + carrier_gateway_id         = ""
              + cidr_block                 = "0.0.0.0/0"
              + core_network_arn           = ""
              + destination_prefix_list_id = ""
              + egress_only_gateway_id     = ""
              + gateway_id                 = ""
              + instance_id                = ""
              + ipv6_cidr_block            = ""
              + local_gateway_id           = ""
              + nat_gateway_id             = (known after apply)
              + network_interface_id       = ""
              + transit_gateway_id         = ""
              + vpc_endpoint_id            = ""
              + vpc_peering_connection_id  = ""
            },
        ]
      + tags_all         = (known after apply)
      + vpc_id           = (known after apply)
    }

  # module.superfluid_ecs.aws_route_table_association.private[0] will be created
  + resource "aws_route_table_association" "private" {
      + id             = (known after apply)
      + route_table_id = (known after apply)
      + subnet_id      = (known after apply)
    }

  # module.superfluid_ecs.aws_route_table_association.private[1] will be created
  + resource "aws_route_table_association" "private" {
      + id             = (known after apply)
      + route_table_id = (known after apply)
      + subnet_id      = (known after apply)
    }

  # module.superfluid_ecs.aws_subnet.private[0] will be created
  + resource "aws_subnet" "private" {
      + arn                                            = (known after apply)
      + assign_ipv6_address_on_creation                = false
      + availability_zone                              = "us-east-1a"
      + availability_zone_id                           = (known after apply)
      + cidr_block                                     = "10.0.0.0/28"
      + enable_dns64                                   = false
      + enable_resource_name_dns_a_record_on_launch    = false
      + enable_resource_name_dns_aaaa_record_on_launch = false
      + id                                             = (known after apply)
      + ipv6_cidr_block_association_id                 = (known after apply)
      + ipv6_native                                    = false
      + map_public_ip_on_launch                        = false
      + owner_id                                       = (known after apply)
      + private_dns_hostname_type_on_launch            = (known after apply)
      + tags_all                                       = (known after apply)
      + vpc_id                                         = (known after apply)
    }

  # module.superfluid_ecs.aws_subnet.private[1] will be created
  + resource "aws_subnet" "private" {
      + arn                                            = (known after apply)
      + assign_ipv6_address_on_creation                = false
      + availability_zone                              = "us-east-1b"
      + availability_zone_id                           = (known after apply)
      + cidr_block                                     = "10.0.0.16/28"
      + enable_dns64                                   = false
      + enable_resource_name_dns_a_record_on_launch    = false
      + enable_resource_name_dns_aaaa_record_on_launch = false
      + id                                             = (known after apply)
      + ipv6_cidr_block_association_id                 = (known after apply)
      + ipv6_native                                    = false
      + map_public_ip_on_launch                        = false
      + owner_id                                       = (known after apply)
      + private_dns_hostname_type_on_launch            = (known after apply)
      + tags_all                                       = (known after apply)
      + vpc_id                                         = (known after apply)
    }

  # module.superfluid_ecs.aws_subnet.public[0] will be created
  + resource "aws_subnet" "public" {
      + arn                                            = (known after apply)
      + assign_ipv6_address_on_creation                = false
      + availability_zone                              = "us-east-1a"
      + availability_zone_id                           = (known after apply)
      + cidr_block                                     = "10.0.0.32/28"
      + enable_dns64                                   = false
      + enable_resource_name_dns_a_record_on_launch    = false
      + enable_resource_name_dns_aaaa_record_on_launch = false
      + id                                             = (known after apply)
      + ipv6_cidr_block_association_id                 = (known after apply)
      + ipv6_native                                    = false
      + map_public_ip_on_launch                        = true
      + owner_id                                       = (known after apply)
      + private_dns_hostname_type_on_launch            = (known after apply)
      + tags_all                                       = (known after apply)
      + vpc_id                                         = (known after apply)
    }

  # module.superfluid_ecs.aws_subnet.public[1] will be created
  + resource "aws_subnet" "public" {
      + arn                                            = (known after apply)
      + assign_ipv6_address_on_creation                = false
      + availability_zone                              = "us-east-1b"
      + availability_zone_id                           = (known after apply)
      + cidr_block                                     = "10.0.0.48/28"
      + enable_dns64                                   = false
      + enable_resource_name_dns_a_record_on_launch    = false
      + enable_resource_name_dns_aaaa_record_on_launch = false
      + id                                             = (known after apply)
      + ipv6_cidr_block_association_id                 = (known after apply)
      + ipv6_native                                    = false
      + map_public_ip_on_launch                        = true
      + owner_id                                       = (known after apply)
      + private_dns_hostname_type_on_launch            = (known after apply)
      + tags_all                                       = (known after apply)
      + vpc_id                                         = (known after apply)
    }

  # module.superfluid_ecs.random_string.cluster will be created
  + resource "random_string" "cluster" {
      + id          = (known after apply)
      + keepers     = {
          + "environ" = "production"
          + "name"    = "superfluid-sentinel"
        }
      + length      = 8
      + lower       = false
      + min_lower   = 0
      + min_numeric = 0
      + min_special = 0
      + min_upper   = 0
      + number      = true
      + numeric     = true
      + result      = (known after apply)
      + special     = false
      + upper       = true
    }

  # module.superfluid_ecs_task.data.aws_secretsmanager_secret_version.superfluid_sentinel_secrets will be read during apply
  # (depends on a resource or a module with changes pending)
 <= data "aws_secretsmanager_secret_version" "superfluid_sentinel_secrets" {
      + arn            = (known after apply)
      + id             = (known after apply)
      + secret_binary  = (sensitive value)
      + secret_id      = "superfluid/sentinel"
      + secret_string  = (sensitive value)
      + version_id     = (known after apply)
      + version_stages = (known after apply)
    }

  # module.superfluid_ecs_task.data.aws_subnet_ids.superfluid will be read during apply
  # (config refers to values not yet known)
 <= data "aws_subnet_ids" "superfluid" {
      + id     = (known after apply)
      + ids    = (known after apply)
      + tags   = (known after apply)
      + vpc_id = (known after apply)

      + timeouts {
          + read = (known after apply)
        }
    }

  # module.superfluid_ecs_task.aws_cloudwatch_log_group.main will be created
  + resource "aws_cloudwatch_log_group" "main" {
      + arn               = (known after apply)
      + id                = (known after apply)
      + kms_key_id        = (known after apply)
      + name              = "/aws/ecs/superfluid-sentinel"
      + name_prefix       = (known after apply)
      + retention_in_days = 1
      + skip_destroy      = false
      + tags              = {
          + "Application" = "superfluid-sentinel"
        }
      + tags_all          = {
          + "Application" = "superfluid-sentinel"
        }
    }

  # module.superfluid_ecs_task.aws_cloudwatch_metric_alarm.ecs_task_running will be created
  + resource "aws_cloudwatch_metric_alarm" "ecs_task_running" {
      + actions_enabled                       = true
      + alarm_actions                         = (known after apply)
      + alarm_description                     = "Superfluid ECS CloudWatch Alarm to have sure that we have at minimum 1 Running task into the cluster"
      + alarm_name                            = "superfluid-sentinel-ecs-task-running-alarm"
      + arn                                   = (known after apply)
      + comparison_operator                   = "LessThanThreshold"
      + evaluate_low_sample_count_percentiles = (known after apply)
      + evaluation_periods                    = 1
      + id                                    = (known after apply)
      + tags_all                              = (known after apply)
      + threshold                             = 1
      + treat_missing_data                    = "missing"

      + metric_query {
          + id          = "m1"
          + return_data = false

          + metric {
              + dimensions  = (known after apply)
              + metric_name = "RunningTaskCount"
              + namespace   = "ECS/ContainerInsights"
              + period      = 60
              + stat        = "Sum"
              + unit        = "Count"
            }
        }
      + metric_query {
          + id          = "m2"
          + return_data = false

          + metric {
              + dimensions  = (known after apply)
              + metric_name = "DesiredTaskCount"
              + namespace   = "ECS/ContainerInsights"
              + period      = 60
              + stat        = "Sum"
              + unit        = "Count"
            }
        }
      + metric_query {
          + expression  = "IF(m1 <= m2, 1, 0)"
          + id          = "e1"
          + label       = "DesiredCountNotMet"
          + return_data = true
        }
    }

  # module.superfluid_ecs_task.aws_ecs_service.superfluid_sentinel_service will be created
  + resource "aws_ecs_service" "superfluid_sentinel_service" {
      + cluster                            = (known after apply)
      + deployment_maximum_percent         = 200
      + deployment_minimum_healthy_percent = 100
      + desired_count                      = 1
      + enable_ecs_managed_tags            = false
      + enable_execute_command             = false
      + iam_role                           = (known after apply)
      + id                                 = (known after apply)
      + launch_type                        = "FARGATE"
      + name                               = "superfluid-sentinel-svc"
      + platform_version                   = (known after apply)
      + scheduling_strategy                = "REPLICA"
      + tags_all                           = (known after apply)
      + task_definition                    = (known after apply)
      + triggers                           = (known after apply)
      + wait_for_steady_state              = false

      + network_configuration {
          + assign_public_ip = false
          + security_groups  = (known after apply)
          + subnets          = (known after apply)
        }
    }

  # module.superfluid_ecs_task.aws_ecs_task_definition.superfluid_sentinel will be created
  + resource "aws_ecs_task_definition" "superfluid_sentinel" {
      + arn                      = (known after apply)
      + container_definitions    = (known after apply)
      + cpu                      = "256"
      + execution_role_arn       = (known after apply)
      + family                   = "superfluid-sentinel-definition"
      + id                       = (known after apply)
      + memory                   = "1024"
      + network_mode             = "awsvpc"
      + requires_compatibilities = [
          + "FARGATE",
        ]
      + revision                 = (known after apply)
      + skip_destroy             = false
      + tags_all                 = (known after apply)

      + volume {
          + name = "data"
        }
    }

  # module.superfluid_ecs_task.aws_sns_topic.superfluid_principal will be created
  + resource "aws_sns_topic" "superfluid_principal" {
      + arn                         = (known after apply)
      + content_based_deduplication = false
      + fifo_topic                  = false
      + id                          = (known after apply)
      + name                        = "superfluid-sentinel-notification"
      + name_prefix                 = (known after apply)
      + owner                       = (known after apply)
      + policy                      = (known after apply)
      + tags                        = (known after apply)
      + tags_all                    = (known after apply)
    }

  # module.superfluid_ecs_task.aws_sns_topic_subscription.superfluid_principal_email will be created
  + resource "aws_sns_topic_subscription" "superfluid_principal_email" {
      + arn                             = (known after apply)
      + confirmation_timeout_in_minutes = 1
      + confirmation_was_authenticated  = (known after apply)
      + endpoint                        = "gabriel.bragavera@gmail.com"
      + endpoint_auto_confirms          = false
      + filter_policy_scope             = (known after apply)
      + id                              = (known after apply)
      + owner_id                        = (known after apply)
      + pending_confirmation            = (known after apply)
      + protocol                        = "email"
      + raw_message_delivery            = false
      + topic_arn                       = (known after apply)
    }

  # module.superfluid_vpc.aws_vpc.superfluid_ecs_vpc will be created
  + resource "aws_vpc" "superfluid_ecs_vpc" {
      + arn                                  = (known after apply)
      + cidr_block                           = "10.0.0.0/20"
      + default_network_acl_id               = (known after apply)
      + default_route_table_id               = (known after apply)
      + default_security_group_id            = (known after apply)
      + dhcp_options_id                      = (known after apply)
      + enable_classiclink                   = (known after apply)
      + enable_classiclink_dns_support       = (known after apply)
      + enable_dns_hostnames                 = (known after apply)
      + enable_dns_support                   = true
      + enable_network_address_usage_metrics = (known after apply)
      + id                                   = (known after apply)
      + instance_tenancy                     = "default"
      + ipv6_association_id                  = (known after apply)
      + ipv6_cidr_block                      = (known after apply)
      + ipv6_cidr_block_network_border_group = (known after apply)
      + main_route_table_id                  = (known after apply)
      + owner_id                             = (known after apply)
      + tags                                 = {
          + "Name" = "superfluid-ecs-vpc"
        }
      + tags_all                             = {
          + "Name" = "superfluid-ecs-vpc"
        }
    }

  # module.superfluid_ecs_task.module.cloudwatch_kms_key.data.aws_caller_identity.current will be read during apply
  # (depends on a resource or a module with changes pending)
 <= data "aws_caller_identity" "current" {
      + account_id = (known after apply)
      + arn        = (known after apply)
      + id         = (known after apply)
      + user_id    = (known after apply)
    }

  # module.superfluid_ecs_task.module.cloudwatch_kms_key.data.aws_iam_policy_document.cloudwatch will be read during apply
  # (config refers to values not yet known)
 <= data "aws_iam_policy_document" "cloudwatch" {
      + id        = (known after apply)
      + json      = (known after apply)
      + policy_id = "key-policy-cloudwatch"

      + statement {
          + actions   = [
              + "kms:*",
            ]
          + effect    = "Allow"
          + resources = [
              + "*",
            ]
          + sid       = "Enable IAM User Permissions"

          + principals {
              + identifiers = [
                  + (known after apply),
                ]
              + type        = "AWS"
            }
        }
      + statement {
          + actions   = [
              + "kms:Decrypt*",
              + "kms:Describe*",
              + "kms:Encrypt*",
              + "kms:GenerateDataKey*",
              + "kms:ReEncrypt*",
            ]
          + effect    = "Allow"
          + resources = [
              + "*",
            ]
          + sid       = "AllowCloudWatchLogs"

          + principals {
              + identifiers = [
                  + (known after apply),
                ]
              + type        = "Service"
            }
        }
    }

  # module.superfluid_ecs_task.module.cloudwatch_kms_key.data.aws_partition.current will be read during apply
  # (depends on a resource or a module with changes pending)
 <= data "aws_partition" "current" {
      + dns_suffix         = (known after apply)
      + id                 = (known after apply)
      + partition          = (known after apply)
      + reverse_dns_prefix = (known after apply)
    }

  # module.superfluid_ecs_task.module.cloudwatch_kms_key.data.aws_region.current will be read during apply
  # (depends on a resource or a module with changes pending)
 <= data "aws_region" "current" {
      + description = (known after apply)
      + endpoint    = (known after apply)
      + id          = (known after apply)
      + name        = (known after apply)
    }

  # module.superfluid_ecs_task.module.cloudwatch_kms_key.aws_kms_alias.cloudwatch will be created
  + resource "aws_kms_alias" "cloudwatch" {
      + arn            = (known after apply)
      + id             = (known after apply)
      + name           = "alias/superfluid-sentinel-cloudwatch-logs"
      + name_prefix    = (known after apply)
      + target_key_arn = (known after apply)
      + target_key_id  = (known after apply)
    }

  # module.superfluid_ecs_task.module.cloudwatch_kms_key.aws_kms_key.cloudwatch will be created
  + resource "aws_kms_key" "cloudwatch" {
      + arn                                = (known after apply)
      + bypass_policy_lockout_safety_check = false
      + customer_master_key_spec           = "SYMMETRIC_DEFAULT"
      + deletion_window_in_days            = 30
      + description                        = "A KMS key used to encrypt data-at-rest stored in CloudWatch Logs."
      + enable_key_rotation                = true
      + id                                 = (known after apply)
      + is_enabled                         = true
      + key_id                             = (known after apply)
      + key_usage                          = "ENCRYPT_DECRYPT"
      + multi_region                       = (known after apply)
      + policy                             = (known after apply)
      + tags                               = {
          + "Application" = "superfluid-sentinel"
        }
      + tags_all                           = {
          + "Application" = "superfluid-sentinel"
        }
    }

  # module.superfluid_ecs_task.module.ecs_task_execution_role.data.aws_caller_identity.current will be read during apply
  # (depends on a resource or a module with changes pending)
 <= data "aws_caller_identity" "current" {
      + account_id = (known after apply)
      + arn        = (known after apply)
      + id         = (known after apply)
      + user_id    = (known after apply)
    }

  # module.superfluid_ecs_task.module.ecs_task_execution_role.data.aws_iam_policy_document.assume_role_policy will be read during apply
  # (depends on a resource or a module with changes pending)
 <= data "aws_iam_policy_document" "assume_role_policy" {
      + id   = (known after apply)
      + json = (known after apply)

      + statement {
          + actions = [
              + "sts:AssumeRole",
            ]
          + effect  = "Allow"

          + principals {
              + identifiers = [
                  + "ecs-tasks.amazonaws.com",
                ]
              + type        = "Service"
            }
        }
    }

  # module.superfluid_ecs_task.module.ecs_task_execution_role.data.aws_iam_policy_document.main will be read during apply
  # (config refers to values not yet known)
 <= data "aws_iam_policy_document" "main" {
      + id   = (known after apply)
      + json = (known after apply)

      + statement {
          + actions   = [
              + "logs:CreateLogGroup",
            ]
          + effect    = "Allow"
          + resources = (known after apply)
          + sid       = "CreateCloudWatchLogGroups"
        }
      + statement {
          + actions   = [
              + "logs:CreateLogStream",
              + "logs:PutLogEvents",
            ]
          + effect    = "Allow"
          + resources = (known after apply)
          + sid       = "CreateCloudWatchLogStreamsAndPutLogEvents"
        }
      + statement {
          + actions   = [
              + "ecr:BatchCheckLayerAvailability",
              + "ecr:BatchGetImage",
              + "ecr:GetAuthorizationToken",
              + "ecr:GetDownloadUrlForLayer",
            ]
          + effect    = "Allow"
          + resources = [
              + "*",
            ]
          + sid       = "GetContainerImage"
        }
    }

  # module.superfluid_ecs_task.module.ecs_task_execution_role.data.aws_partition.current will be read during apply
  # (depends on a resource or a module with changes pending)
 <= data "aws_partition" "current" {
      + dns_suffix         = (known after apply)
      + id                 = (known after apply)
      + partition          = (known after apply)
      + reverse_dns_prefix = (known after apply)
    }

  # module.superfluid_ecs_task.module.ecs_task_execution_role.data.aws_region.current will be read during apply
  # (depends on a resource or a module with changes pending)
 <= data "aws_region" "current" {
      + description = (known after apply)
      + endpoint    = (known after apply)
      + id          = (known after apply)
      + name        = (known after apply)
    }

  # module.superfluid_ecs_task.module.ecs_task_execution_role.aws_iam_policy.main will be created
  + resource "aws_iam_policy" "main" {
      + arn         = (known after apply)
      + description = "The policy for app-superfluid-sentinel-task-execution-role."
      + id          = (known after apply)
      + name        = "app-superfluid-sentinel-task-execution-role-policy"
      + path        = "/"
      + policy      = (known after apply)
      + policy_id   = (known after apply)
      + tags_all    = (known after apply)
    }

  # module.superfluid_ecs_task.module.ecs_task_execution_role.aws_iam_role.main will be created
  + resource "aws_iam_role" "main" {
      + arn                   = (known after apply)
      + assume_role_policy    = (known after apply)
      + create_date           = (known after apply)
      + force_detach_policies = false
      + id                    = (known after apply)
      + managed_policy_arns   = (known after apply)
      + max_session_duration  = 3600
      + name                  = "app-superfluid-sentinel-task-execution-role"
      + name_prefix           = (known after apply)
      + path                  = "/"
      + tags                  = {
          + "Application" = "superfluid-sentinel"
        }
      + tags_all              = {
          + "Application" = "superfluid-sentinel"
        }
      + unique_id             = (known after apply)

      + inline_policy {
          + name   = (known after apply)
          + policy = (known after apply)
        }
    }

  # module.superfluid_ecs_task.module.ecs_task_execution_role.aws_iam_role_policy_attachment.main will be created
  + resource "aws_iam_role_policy_attachment" "main" {
      + id         = (known after apply)
      + policy_arn = (known after apply)
      + role       = "app-superfluid-sentinel-task-execution-role"
    }

  # module.superfluid_ecs_task.module.superfluid_sentinel_task_sg.aws_security_group.this_name_prefix[0] will be created
  + resource "aws_security_group" "this_name_prefix" {
      + arn                    = (known after apply)
      + description            = "Access internet"
      + egress                 = (known after apply)
      + id                     = (known after apply)
      + ingress                = (known after apply)
      + name                   = (known after apply)
      + name_prefix            = "superfluid-sentinel-task-sg-"
      + owner_id               = (known after apply)
      + revoke_rules_on_delete = false
      + tags                   = {
          + "Name" = "superfluid-sentinel-task-sg"
        }
      + tags_all               = {
          + "Name" = "superfluid-sentinel-task-sg"
        }
      + vpc_id                 = (known after apply)
    }

  # module.superfluid_ecs_task.module.superfluid_sentinel_task_sg.aws_security_group_rule.egress_rules[0] will be created
  + resource "aws_security_group_rule" "egress_rules" {
      + cidr_blocks              = [
          + "0.0.0.0/0",
        ]
      + description              = "All protocols"
      + from_port                = -1
      + id                       = (known after apply)
      + ipv6_cidr_blocks         = [
          + "::/0",
        ]
      + prefix_list_ids          = []
      + protocol                 = "-1"
      + security_group_id        = (known after apply)
      + security_group_rule_id   = (known after apply)
      + self                     = false
      + source_security_group_id = (known after apply)
      + to_port                  = -1
      + type                     = "egress"
    }

  # module.superfluid_ecs_task.module.superfluid_sentinel_task_sg.aws_security_group_rule.ingress_rules[0] will be created
  + resource "aws_security_group_rule" "ingress_rules" {
      + cidr_blocks              = [
          + "0.0.0.0/0",
        ]
      + description              = "HTTP"
      + from_port                = 80
      + id                       = (known after apply)
      + ipv6_cidr_blocks         = []
      + prefix_list_ids          = []
      + protocol                 = "tcp"
      + security_group_id        = (known after apply)
      + security_group_rule_id   = (known after apply)
      + self                     = false
      + source_security_group_id = (known after apply)
      + to_port                  = 80
      + type                     = "ingress"
    }

  # module.superfluid_ecs_task.module.superfluid_sentinel_task_sg.aws_security_group_rule.ingress_rules[1] will be created
  + resource "aws_security_group_rule" "ingress_rules" {
      + cidr_blocks              = [
          + "0.0.0.0/0",
        ]
      + description              = "HTTPS"
      + from_port                = 443
      + id                       = (known after apply)
      + ipv6_cidr_blocks         = []
      + prefix_list_ids          = []
      + protocol                 = "tcp"
      + security_group_id        = (known after apply)
      + security_group_rule_id   = (known after apply)
      + self                     = false
      + source_security_group_id = (known after apply)
      + to_port                  = 443
      + type                     = "ingress"
    }

Plan: 32 to add, 0 to change, 0 to destroy.

Warning: Deprecated Resource

  with module.superfluid_ecs_task.data.aws_subnet_ids.superfluid,
  on modules/ecs-task/service.tf line 23, in data "aws_subnet_ids" "superfluid":
  23: data "aws_subnet_ids" "superfluid" {

The aws_subnet_ids data source has been deprecated and will be removed in a
future version. Use the aws_subnets data source instead.

Warning: Argument is deprecated

  with module.superfluid_ecs.aws_ecs_cluster.superfluid_ecs_cluster_main,
  on modules/ecs/main.tf line 21, in resource "aws_ecs_cluster" "superfluid_ecs_cluster_main":
  21: resource "aws_ecs_cluster" "superfluid_ecs_cluster_main" {

Use the aws_ecs_cluster_capacity_providers resource instead

(and one more similar warning elsewhere)

─────────────────────────────────────────────────────────────────────────────

Note: You didn't use the -out option to save this plan, so Terraform can't
guarantee to take exactly these actions if you run "terraform apply" now.

Pushed by: @kevencript, Action: pull_request