Définissez vos conteneurs dans votre environnement Azure Container Apps avec Terraform

Dans ce tutoriel, vous commencerez à définir vos conteneurs frontend et backend dans l’environnement Azure Container Apps et l’Azure Cosmos Db associés avec Terraform. Cela se fera dans le groupe de ressources créé dans le tutoriel précédent.

Ce tutoriel fait partie d’une série complète de tutoriels sur l’utilisation d’Azure Container Apps avec Terraform.

Déployer la base de données Azure Cosmos

Pour stocker le résultat des appels d’API, vous utiliserez une base de données Azure Cosmos Db et définirez une base de données mongo nommée ratingsdb.

Pour ce faire, créons un fichier appelé cosmos-db.tf et ajoutons ce code :

resource "azurerm_cosmosdb_account" "this" {
  name                = format("cosmos-%s", local.resource_suffix_kebabcase)
  location            = azurerm_resource_group.this.location
  resource_group_name = azurerm_resource_group.this.name
  offer_type          = "Standard"
  kind                = "MongoDB"

  capabilities {
    name = "mongoEnableDocLevelTTL"
  }

  capabilities {
    name = "MongoDBv3.4"
  }

  capabilities {
    name = "EnableMongo"
  }

  capabilities {
    name = "EnableServerless"
  }

  consistency_policy {
    consistency_level       = "Session"
    max_interval_in_seconds = 5
    max_staleness_prefix    = 100
  }

  geo_location {
    location          = azurerm_resource_group.this.location
    failover_priority = 0
  }
}

resource "azurerm_cosmosdb_mongo_database" "this" {
  name                = "ratingsdb"
  resource_group_name = azurerm_cosmosdb_account.this.resource_group_name
  account_name        = azurerm_cosmosdb_account.this.name
}

Pour continuer dans l’esprit du serverless comme Azure Container Apps, comme vous pouvez le constater, Azure Cosmos Db est activé avec le mode serverless .

Définir le conteneur pour le backend

Dans le tutoriel précédent, vous avez créé l’environnement Azure Container Apps. Vous allez maintenant lui définir le conteneur pour le backend.

Tout d’abord, créez un fichier appelé container-api.tf et ajoutez ce code :

resource "azurerm_container_app" "api" {
  name                         = format("ca-api-%s", local.resource_suffix_kebabcase)
  container_app_environment_id = azurerm_container_app_environment.this.id
  resource_group_name          = azurerm_resource_group.this.name
  revision_mode                = "Single"

  lifecycle {
    ignore_changes = [
      template.0.container[0].image
    ]
  }

  registry {
    server   = azurerm_container_registry.this.login_server
    username = azurerm_container_registry.this.admin_username
  }

  ingress {
    external_enabled = true
    target_port      = 3000
    traffic_weight {
      percentage      = 100
      latest_revision = true
    }
  }

  template {
    container {
      name   = format("ca-api")
      image  = "crdevwefrt01.azurecr.io/fruits-backend:1.0.0"
      cpu    = 0.25
      memory = "0.5Gi"
    }

    min_replicas = 0
  }
}

Assurez-vous de remplacer l’attribut image par celui de votre propre image registry.

Si vous regardez le Dockerfile à l’intérieur du répetoire GitHub, vous verrez que le port 3000 est exposé. Vous devez donc le définir sur 3000 l’attribut target_port du bloc ingress.

L’attribut image du conteneur est ignoré à l’aide du bloc lifecycle afin qu’il puisse être géré par votre pipeline CI/CD.

Par défaut, vous pouvez voir que min_replicas est défini sur 0. Cela signifie que le conteneur ne sera pas démarré tant que la première requête n’aura pas été reçue. C’est un excellent moyen d’économiser de l’argent et des ressources.

Pour récupérer l’image Docker à partir d’un Azure Container Registry, vous devez définir l’attribut registry et le lier au registre que vous avez créé dans le tutoriel précédent.

Le mot de passe sera fourni à l’aide de secrets dans le prochain tutoriel.

Définir le conteneur frontend

Après le conteneur backend, c’est le moment de définir le conteneur frontend. Pour cela, créez un fichier nommé container-web.tf et ajoutez ce code :

resource "azurerm_container_app" "web" {
  name                         = format("ca-web-%s", local.resource_suffix_kebabcase)
  container_app_environment_id = azurerm_container_app_environment.this.id
  resource_group_name          = azurerm_resource_group.this.name
  revision_mode                = "Single"

  registry {
    server   = azurerm_container_registry.this.login_server
    username = azurerm_container_registry.this.admin_username
  }

  lifecycle {
    ignore_changes = [
      template.0.container[0].image
    ]
  }

  ingress {
    external_enabled = true
    target_port      = 8080
    traffic_weight {
      percentage      = 100
      latest_revision = true
    }
  }

  template {
    container {
      name   = format("ca-web")
      image  = "crdevwefrt01.azurecr.io/fruits-frontend:1.0.0"
      cpu    = 0.25
      memory = "0.5Gi"
    }
    min_replicas = 0
  }
}

N’oubliez pas de remplacer l’attribut image par votre propre image registry.

Comme le conteneur backend, le conteneur frontend est lié à Azure Container Registry et l’attribut image est ignoré. Le target_port est défini sur 8080 comme défini dans le Dockerfile, voir le répertoire GitHub.

Touche finale

Vous avez défini vos applications de conteneur et Cosmos Db sans serveur pour MongoDb. Vous trouverez le code source complet dans ce dépôt Github.

Et après?

Dans le tutoriel suivant de cette série, nous nous concentrerons sur le déploiement des Azure Container Apps et déclarerons des secrets et des variables d’environnement pour les conteneurs.

N'hésitez pas à me suivre sur Twitter pour ne pas rater mon prochain tutoriel !