Thomas Charrier

3 juillet 2017

Déployer rapidement des agents VSTS avec Windows Containers, Docker et Azure

Dans cet article on va mettre en application une nouvelle fonctionnalité disponible pour Windows Server 2016 et Windows 10 Anniversary Edition : les Windows Containers.
En effet, depuis peu, il est maintenant possible de monter des images Docker Windows sur ces 2 versions de Windows ! On va mettre en pratique cette nouvelle fonctionnalité en construisant une image Docker permettant de créer facilement et rapidement des agents de build/release pour VSTS/TFS !
Ensuite, pour faciliter sa distribution, on mettra le container créé dans un Container Registry sur Azure.

Installation manuelle de Windows Containers

Pour l’installation, je vous invite à lire l’article de Julien Corioland : Getting Started with Windows Containers.
Je vous laisse 5 minutes… C’est bon ? Tout est installé ? 🙂 Pour ceux du fond qui n’ont pas lu, rapide résumé :

Activation de la feature Windows Containers

Enable-WindowsOptionalFeature -Online -FeatureName containers –All
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V –All 
Restart-Computer –Force

Téléchargement de Docker
Installation de Docker

Il suffit de dézipper ce que l’on vient de télécharger dans le répertoire C:\Program Files\Docker.

Enregistrement de Docker

[Environment]::SetEnvironmentVariable(“Path”, $env:Path + “;C:\Program Files\Docker”, [EnvironmentVariableTarget]::Machine)
dockerd –register-service

Démarrage du service

Start-Service Docker

Installation via Chocolatey

Ou plus simplement, on peut installer Docker via Chocolatey via la commande

choco install docker

En suivant les instruction, l’installation se fait sans soucis :

Vérification de l’installation

On peut vérifier que Docker est correctement installer en faisant

Docker version

Création de notre image

Microsoft a mis à disposition une image sur le Hub Docker avec un agent VSTS, mais celle-ci est basée sur Ubuntu, on va donc ici se créer une image basée sur Windows Server et l’enregistrer sur un Container Registry privé sur Azure.

Pour simplifier, on va utiliser un fichier dockerfile qui va contenir l’ensemble des actions que l’on veut faire, ce qui va permettre de créer l’image directement avec tout ce qu’il faut dedans. Et on pourra ainsi créer de nouvelles images lorsque les outils évolueront !

Le contenu du fichier est le suivant :

FROM microsoft/windowsservercore
MAINTAINER ThomasCharrier

COPY ["buildtools_full.exe", "c:/BuildTools/buildtools_full.exe"]
RUN c:/BuildTools/buildtools_full.exe -quiet

COPY ["NDP46-KB3045557-x86-x64-AllOS-ENU.exe", "c:/Framework/NDP46-KB3045557-x86-x64-AllOS-ENU.exe"]
RUN c:/Framework/NDP46-KB3045557-x86-x64-AllOS-ENU.exe /q /norestart

COPY ["vsts-agent-win7-x64-2.110.0.zip", "c:/VSTSAgentInstall/vsts-agent-win7-x64-2.110.0.zip"]

WORKDIR C:/
COPY ./start.* ./

ENV VSTS_ACCOUNT ""
ENV VSTS_TOKEN ""
ENV VSTS_AGENTNAME ""
ENV VSTS_POOL ""

CMD ["start.cmd"]

De plus, l’ensemble des outils ainsi que le fichier DockerFile seront dans un même répertoire, afin de simplifier les commandes de copie et de création de l’image:

Regardons maintenant ce qui se passe sous le capot.

Récupération l’image a partir du Hub Docker

Pour commencer, on va récupérer sur notre serveur l’image qui nous intéresse, on va partir de l’image de base Windows Server Core.

docker search microsoft
docker pull microsoft/windowsservercore

Ensuite dans notre fichier DockerFile on indique que notre image sera basé sur celle-ci.
On indique également qui a créé cette image.

FROM microsoft/windowsservercore
MAINTAINER ThomasCharrier

Installation des Build Tools

Afin de pouvoir compiler nos projets, on va installer le Framework ainsi que les Build Tools. Dans notre dockerfile on aura une commande de COPY et une de RUN afin de lancer l’installation, comme paramètre on ajoutera le fait de faire ces installations en mode silencieux.

COPY ["buildtools_full.exe", "c:/BuildTools/buildtools_full.exe"]
RUN c:/BuildTools/buildtools_full.exe -quiet

COPY ["NDP46-KB3045557-x86-x64-AllOS-ENU.exe", "c:/Framework/NDP46-KB3045557-x86-x64-AllOS-ENU.exe"]
RUN c:/Framework/NDP46-KB3045557-x86-x64-AllOS-ENU.exe /q /norestart

On vérifie que l’installation est terminée et que nous disposons de tout ce qu’il nous faut en allant voir dans le répertoire “c:/Program Files (x86)/MSBuild/” par exemple.

Installation de l’agent VSTS

On ne va pas vraiment installer l’agent, on va juste le dézipper dans un répertoire, afin que l’installation se fasse lors du lancement de l’image.
Même chose qu’au dessus, on copie le fichier, qui sera dezippé dans le script de démarrage.

COPY ["vsts-agent-win7-x64-2.110.0.zip", "C:\VSTSAgentInstall\vsts-agent-win7-x64-2.110.0.zip"]

Afin de gérer les paramètres d’installation de l’agent, on va créer des variables d’environnements qu’on va surcharger selon nos besoins à chaque lancement :

VSTS_ACCOUNT : Url de notre VSTS,
VSTS_TOKEN : Personnal Access Token que vous avez généré sur votre profil VSTS,
VSTS_AGENTNAME : Nom que vous voulez donner à votre agent,
VSTS_POOL : Nom de la pool dans laquelle doit être enregisté l’agent,
VSTS_HTTP_PROXY : Proxy pour l’agent VSTS (si besoin, il est fort a parier que oui si votre machine est On-Premise).

Ça donne ceci dans notre fichier DockerFile

ENV VSTS_ACCOUNT ""
ENV VSTS_TOKEN ""
ENV VSTS_AGENTPWD = ""
ENV VSTS_POOL ""

Installation automatique de l’agent

On va faire en sorte que lors du lancement du container à partir de notre image, l’installation et l’enregistrement de l’agent sur VSTS/TFS se fassent automatiquement.
On va créer des scripts shell/Powershell pour lancer la commande d’instanciation. L’installation de l’agent se fera donc avec des valeurs qui sont présentes dans des variables d’environnement.

CMD ["start.cmd"]

Contenu du fichier start.cmd

PowerShell.exe -ExecutionPolicy ByPass .\Start.ps1

Contenu du fichier start.ps1

#Dezip agent
$file = "C:\VSTSAgentInstall\vsts-agent-win7-x64-2.110.0.zip"
$path = $env:HOMEDRIVE + "\VSTSAgent\"
New-item $path -type directory

Add-Type -assembly "system.io.compression.filesystem"
[io.compression.zipfile]::ExtractToDirectory($file,$path)

#Install agent
C:\VSTSAgent\bin\Agent.Listener.exe configure --url "$env:VSTS_ACCOUNT" --auth PAT --token "$env:VSTS_TOKEN" --agent "$env:VSTS_AGENTNAME" --pool "$env:VSTS_POOL" --work "c:\_work" --unattended

#Run agent
C:\VSTSAgent\bin\Agent.Listener.exe run

Création

Pour lancer la création de notre image il suffit d’exécuter la commande suivante, on y indique le nom de notre future image

docker build -t vstsagent .

Lors de la construction, les différentes étapes apparaissent. Puis on vérifie la présence de notre image.

Enregistrement de l’image sur Azure

Pour rebondir sur l’article de Matthieu : Docker sur Azure Web App avec Container Registry, qui vous a appris à créer un Container Registry sur Azure.

On va donc enregistrer cette image sur notre Container Registry

docker login dockerthomas-on.azurecr.io -u "dockerthomas" -p "XXXXX"
docker tag vstsagent dockerthomas-on.azurecr.io/vstsagent
docker push dockerthomas-on.azurecr.io/vstsagent

On peut voir via le portail Azure que notre image est disponible

Nos collègues pourront disposer de cette image et la lancer de leur côté.

docker login dockerthomas-on.azurecr.io -u "dockerthomas" -p "XXXXX"
docker pull dockerthomas-on.azurecr.io/vstsagent

Lancement de notre image

Justement ! Comment lancer cette image avec les différents paramètres ?
L’image est configurée pour lancer l’installation de l’agent VSTS à son instanciation, on va juste avoir besoin de surcharger les différentes variables d’environnement pour y entrer nos paramètres

docker run 
-e VSTS_ACCOUNT="https://myaccount.visualstudio.com" 
-e VSTS_TOKEN="PAT" 
-e VSTS_AGENTNAME="$(hostname)-agent-01" 
-e VSTS_POOL="Default" 
-it --rm -P vstsagent