Mise en place d'agents Azure DevOps dockerisés

Azure DevOps est un service cloud de Microsoft dédié au développement logiciel collaboratif. En utilisant des méthodes agiles, il permet la gestion de projets de développement logiciel tout en offrant des services d'intégration continue et de déploiement continu (CI/CD). Ces services permettent la création de pipelines automatisés pour tester et déployer automatiquement le code source d'une application. Pour exécuter ces pipelines, des agents Azure DevOps sont nécessaires, pouvant être hébergés soit par Microsoft, soit par l'utilisateur, connus sous le nom d'agents selfhosted.

Pour des agents Azure Devops selfhosted il est possible d'utiliser des machines virtuelles mais il est également possible d'utiliser des conteneurs docker comme nous allons le voir ici. Attention néanmoins, les agents Docker sont plus limités que les machines virtuelles, notamment par leur impossibilité d'utiliser Docker dessus. Pour cela nous allons utiliser Terraform pour déployer nos agents Azure DevOps et notre container registry dans lequel nous stockerons notre image docker utilisée pour déployer nos agents Azure DevOps dockerisés.

Création de l'image docker

Pour pouvoir déployer un agent dockerisé il faut tout d'abord se munir d'une image docker de l'agent Azure DevOps. Pour cela, nous allons utiliser le tutoriel officiel de Microsoft. Ici nous allons build l'image docker pour Linux qui sera par la suite stocké dans un container registry. Pour optimiser votre utilisation de ces agents dockérisés, il est recommandé d'ajuster l'image Docker en y intégrant les outils nécessaires à vos pipelines.

Stockage de l'image docker

Avant de déployer nos instances docker nous allons stocker notre image dans un container registry sur Azure. L'utilisation d'un container registry permet de simplifier le versionning de nos images docker et de centraliser le stockage de celles-ci. Nous allons utiliser Terraform pour le déployer. Nous avons préalablement créé un groupe de ressource pour le stocker. Le code terraform suivant correspond uniquement à la création de notre container registry.

# Create ACR user assigned identity
resource "azurerm_user_assigned_identity" "acr_identity" {
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location

  name = "acrtest-Identity"
  depends_on = [
    azurerm_resource_group.rg,
  ]
}

# Create the Container Registry
resource "azurerm_container_registry" "acr" {
  name                          = "acrtest"
  resource_group_name           = azurerm_resource_group.rg.name
  location                      = azurerm_resource_group.rg.location
  sku                           = "Standard"
  public_network_access_enabled = true
  admin_enabled                 = true
  identity {
    type = "UserAssigned"
    identity_ids = [
      azurerm_user_assigned_identity.acr_identity.id
    ]
  }

  depends_on = [
    azurerm_resource_group.rg,
    azurerm_user_assigned_identity.acr_identity
  ]
}

Comme on peut le voir dans notre code, nous avons lié notre container registry à une user assigned identity. Cela nous permettra de pouvoir accéder à notre container registry sans avoir besoin des credentials de notre container registry.

Une fois le container registry déployé, nous allons pouvoir push notre image docker créée précédemment sur celui-ci grâce à la commande suivante:

tip

Assurez-vous que le nom du conteneur et de l'image correspondent bien à ceux que vous avez créés

az acr login --name "acrtest"
docker push "acrtest.azurecr.io/dockeragentlinux:latest"

warning

Attention, il faut bien s'assurer que notre user assigned identity est bien liée à l'environnement utilisé pour ajouter l'image. Si ce n'est pas le cas il faudra utiliser les credentials de notre container registry.

Déploiement de l'agent Azure DevOps dockerisé

Nous allons utiliser Terraform pour déployer notre agent Azure DevOps. Nous avons préalablement créé un groupe de ressource, un réseau privé et un pool d'agent sur Azure DevOps. Le code terraform suivant correspond uniquement à la création de notre agent Azure DevOps:

resource "azurerm_container_group" "linux-container-group" {
  name                = "dockeragentlinux"
  location            = "France Central"
  resource_group_name = azurerm_resource_group.rg_ci.name
  ip_address_type     = "Private"
  os_type             = "Linux"
  subnet_ids          = [data.azurerm_subnet.subnet.id]

  container {
    name   = "dockeragentlinux"
    image  = "acrtest.azurecr.io/dockeragentlinux:latest"
    cpu    = "1"
    memory = "2"

    ports {
      port     = 80
      protocol = "TCP"
    }

    environment_variables = {
      AZP_URL        = var.azure-devops.organization-url
      AZP_POOL       = var.linux_agents_configuration.agent_pool_name
      AZP_AGENT_NAME = var.linux_agents_configuration.agent_name_prefix
    }

    secure_environment_variables = {
      AZP_TOKEN = var.azure-devops.pat-token
    }
  }

  image_registry_credential {
    username = data.azurerm_container_registry.acr.admin_username
    password = data.azurerm_container_registry.acr.admin_password
    server   = data.azurerm_container_registry.acr.login_server
  }
}

Le code ci-dessus permet de déployer un container group avec un container docker. Un container group correspond à un agent Azure DevOps sous Linux. Il est possible d'utiliser un count pour pouvoir déployer plusieurs agents Azure DevOps en même temps. Nous avons également utilisé des variables pour pouvoir déployer des agents dans notre organisation Azure DevOps; il est donc nécessaire de les adapter à votre organisation. Il est bien évidement possible de modifier le code terraform pour déployer des agents Azure DevOps sous Windows. Pour cela il suffit de modifier la valeur de os_type en "Windows" et de modifier l'image docker pour correspondre à un agent Windows.

Références

Pour plus d'informations sur le fonctionnement des ressources Terraform, consultez la documentation officielle.