namespaces "ingress" not found

[KookaS]

I am trying to deploy labelstudio, I created a wrapper around your deployment but I get the following error.

terraform version 1.4.4
version and providers same as here
region us-west-1

code:

variable "labelstudio" {
  type = object({
    instance_type                         = optional(string, "t3.medium")
    desired_capacity                      = optional(number, 3)
    max_size                              = optional(number, 5)
    min_size                              = optional(number, 3)
    create_acm_certificate                = optional(bool, false)
    eks_capacity_type                     = optional(string, "ON_DEMAND")
    ingress_namespace                     = optional(string, "ingress")
    monitoring_namespace                  = optional(string, "monitoring")
    aws_auth_roles                        = optional(list(any), [])
    aws_auth_users                        = optional(list(any), [])
    aws_auth_accounts                     = optional(list(any), [])
    label_studio_helm_chart_repo          = optional(string, "https://charts.heartex.com")
    label_studio_helm_chart_repo_username = optional(string, "")
    label_studio_helm_chart_repo_password = optional(string, "")
    label_studio_helm_chart_name          = optional(string, "label-studio")
    label_studio_helm_chart_version       = optional(string, "1.0.16")
    label_studio_docker_registry_server   = optional(string, "https://index.docker.io/v2/")
    label_studio_docker_registry_username = optional(string, "")
    label_studio_docker_registry_password = optional(string, "")
    label_studio_docker_registry_email    = optional(string, "")
    label_studio_additional_set           = optional(map(string), {})
    enterprise                            = optional(bool, false)
    deploy_label_studio                   = optional(bool, true)
    license_literal                       = optional(string)
    postgresql_type                       = optional(string, "rds")
    postgresql_machine_type               = optional(string, "db.m5.large")
    postgresql_database                   = optional(string, "labelstudio")
    postgresql_host                       = optional(string, "")
    postgresql_port                       = optional(number, 5432)
    postgresql_username                   = optional(string, "labelstudio")
    postgresql_password                   = optional(string)
    postgresql_ssl_mode                   = optional(string, "require")
    postgresql_tls_key_file               = optional(string)
    postgresql_tls_crt_file               = optional(string)
    postgresql_ca_crt_file                = optional(string)
    redis_type                            = optional(string, "elasticache")
    redis_machine_type                    = optional(string, "cache.t3.micro")
    redis_host                            = optional(string, "")
    redis_port                            = optional(number, 6379)
    redis_password                        = optional(string)
    redis_ssl_mode                        = optional(string, "required")
    redis_ca_crt_file                     = optional(string)
    redis_tls_crt_file                    = optional(string)
    redis_tls_key_file                    = optional(string)
    lets_encrypt_email                    = optional(string)
    cluster_endpoint_public_access_cidrs  = optional(list(string), ["0.0.0.0/0"])
  })

module "labelstudio" {
  source = "git::https://github.com/HumanSignal/label-studio-terraform.git//terraform/aws/env?ref=master"

  name             = lower(var.name_suffix)
  environment      = lower(join("-", compact([var.name_prefix, local.repository_config_vars.project_name, local.repository_config_vars.service_name])))
  region           = local.region_name
  instance_type    = var.labelstudio.instance_type
  desired_capacity = var.labelstudio.desired_capacity
  max_size         = var.labelstudio.max_size
  min_size         = var.labelstudio.min_size

  eks_capacity_type    = var.labelstudio.eks_capacity_type
  ingress_namespace    = var.labelstudio.ingress_namespace
  monitoring_namespace = var.labelstudio.monitoring_namespace
  aws_auth_roles       = var.labelstudio.aws_auth_roles
  aws_auth_users = concat(var.labelstudio.aws_auth_users, [
    # {
    #   userarn  = data.aws_caller_identity.current.arn
    #   username = regex("^arn:aws:iam::\\w+:user\\/(?P<user_name>\\w+)$", data.aws_caller_identity.current.arn).user_name
    #   groups = [
    #     "system:masters",
    #   ]
    # }
  ])
  aws_auth_accounts                     = var.labelstudio.aws_auth_accounts
  label_studio_helm_chart_repo          = var.labelstudio.label_studio_helm_chart_repo
  label_studio_helm_chart_repo_username = var.labelstudio.label_studio_helm_chart_repo_username
  label_studio_helm_chart_repo_password = sensitive(var.labelstudio.label_studio_helm_chart_repo_password)
  label_studio_helm_chart_name          = var.labelstudio.label_studio_helm_chart_name
  label_studio_helm_chart_version       = var.labelstudio.label_studio_helm_chart_version
  label_studio_docker_registry_server   = var.labelstudio.label_studio_docker_registry_server
  label_studio_docker_registry_username = var.labelstudio.label_studio_docker_registry_username
  label_studio_docker_registry_password = sensitive(var.labelstudio.label_studio_docker_registry_password)
  label_studio_docker_registry_email    = var.labelstudio.label_studio_docker_registry_email
  label_studio_additional_set           = var.labelstudio.label_studio_additional_set
  enterprise                            = var.labelstudio.enterprise
  deploy_label_studio                   = var.labelstudio.deploy_label_studio
  license_literal                       = sensitive(var.labelstudio.license_literal)
  postgresql_type                       = var.labelstudio.postgresql_type
  postgresql_machine_type               = var.labelstudio.postgresql_machine_type
  postgresql_database                   = var.labelstudio.postgresql_database
  postgresql_host                       = var.labelstudio.postgresql_host
  postgresql_port                       = var.labelstudio.postgresql_port
  postgresql_username                   = var.labelstudio.postgresql_username
  postgresql_password                   = sensitive(var.labelstudio.postgresql_password)
  postgresql_ssl_mode                   = var.labelstudio.postgresql_ssl_mode
  postgresql_tls_key_file               = var.labelstudio.postgresql_tls_key_file
  postgresql_tls_crt_file               = var.labelstudio.postgresql_tls_crt_file
  postgresql_ca_crt_file                = var.labelstudio.postgresql_ca_crt_file
  redis_type                            = var.labelstudio.redis_type
  redis_machine_type                    = var.labelstudio.redis_machine_type
  redis_host                            = var.labelstudio.redis_host
  redis_port                            = var.labelstudio.redis_port
  redis_password                        = sensitive(var.labelstudio.redis_password)
  redis_ssl_mode                        = var.labelstudio.redis_ssl_mode
  redis_ca_crt_file                     = var.labelstudio.redis_ca_crt_file
  redis_tls_crt_file                    = var.labelstudio.redis_tls_crt_file
  redis_tls_key_file                    = var.labelstudio.redis_tls_key_file
  lets_encrypt_email                    = var.labelstudio.lets_encrypt_email

  # dns
  create_r53_zone        = false
  create_acm_certificate = var.labelstudio.create_acm_certificate
  domain_name            = try(var.route53.zone.name, null)
  record_name            = try(var.route53.record.subdomain_name, null)

  # s3
  predefined_s3_bucket = {
    name : module.bucket_label.bucket.name
    region : local.region_name
    folder : "/"
    kms_arn : module.kms.key_arn
  }

  # # vpc
  # predefined_vpc_id                    = var.vpc.id
  # cluster_endpoint_public_access_cidrs = var.labelstudio.cluster_endpoint_public_access_cidrs
  # create_internet_gateway              = false
  # vpc_cidr_block                       = null
  public_cidr_block  = local.subnets["ls-public"]
  private_cidr_block = local.subnets["ls-private"]
}

inputs :

labelstudio= {
    instance_type = "t3.small"
    desired_capacity = 1
    max_size = 2
    min_size = 1
    label_studio_additional_set = {
	    global.image.repository = "heartexlabs/label-studio"
	    global.image.tag=        "develop"
    }
    postgresql_type=        "rds"
    postgresql_machine_type= "db.m5.large"
    postgresql_password=     "12345678" # testing values
    redis_type=              "elasticache"
    redis_machine_type=       "cache.t3.small"
    redis_password=          "12345678" # testing values
}

permissions:

actions:
        [
          "eks:*",
          "rds:*",
          "ec2:*",
          "autoscaling:*",
          "autoscaling-plans:*",
          "application-autoscaling:*",
          "logs:*",
          "cloudwatch:*",
          "ssm:*",
          "iam:*",
          "kms:*",
          "elasticloadbalancing:*",
        ]
effect: "Allow"
resources: ["*"]

error message:

FatalError{Underlying: error while running command: exit status 1; ╷
│ Error: ingress/vi-scraper-ls-olivier-abcd-aws-load-balancer-controller failed to run apply: error when creating "/tmp/942190243kubectl_manifest.yaml": namespaces "ingress" not found
│ 
│   with module.labelstudio.module.lbc.kubectl_manifest.service_account,
│   on .terraform/modules/labelstudio/terraform/aws/modules/load-balancer-controller/main.tf line 298, in resource "kubectl_manifest" "service_account":
│  298: resource "kubectl_manifest" "service_account" {
│ 
╵
╷
│ Error: failed post-install: timed out waiting for the condition
│ 
│   with module.labelstudio.module.cert-manager.helm_release.this,
│   on .terraform/modules/labelstudio/terraform/common/modules/cert-manager/main.tf line 15, in resource "helm_release" "this":
│   15: resource "helm_release" "this" {
│ 
╵}

[KookaS]

In eu-north-1 it seems to work but not in us-west-1. It also works with a separate s3 bucket.
Most of the comments below apply to us-west-1 where I tried a couple of configurations.
I used my VPC instead of the one create in here and it didn't worked. It might be because I am using terraform 1.5 and aws 5.0.1 to generate it so it might just be forward incompatibility.
Also, not all regions have three available zones, consider using data.aws_availability_zones instead of hardcoding the subnets
For the time being I am only deployint to eu-north-1