Qu'est ce que Docker​

Comme bien expliqué sur opensource.com, Docker est un outil conçu pour faciliter la création, le déploiement et l'exécution d'une application en utilisant des conteneurs.

Les conteneurs permettent à un développeur de packager son application avec toutes les dépendances nécessaires, qu'elles soient de nature logicielle (bibliothèques, framework) ou système (runtime, composant d'OS). Ainsi, grâce au conteneur, le développeur s'assure que l'application peut tourner comme sur son propre environnement, car le conteneur en contient tous les composants paramétrés à l'identique.

Dans un sens, Docker rappelle un peu les machines virtuelles. Mais contrairement à une VM qui répplique tous les composants et un système d'exploitation entier, Docker permet aux applicaitons de n'utiliser que les parties d'un noyau nécessaire à l'éxécution de l'applicatif que le conteneur est destiné à faire tourner sur la machine hôte. Cela permet d'accroitre significativement les performances, et de reduire drastiquement la taille de l'applicatif "virtualisé".

Comment en bénéficier​

Pour pouvoir exécuter un conteneur, il faut d'abord l'avoir téléchargé.

Pour cela, nous devons simplement pull le conteneur préalablement choisi sur le DockerHub.

Pour l'exemple, nous allons démarrer deux conteneur : Nginx et Grafana

Pour cela, entrer dans votre vm et tapez les commandes suivantes :

• Nginx:

docker pull nginx

• Grafana:

docker pull grafana/grafana

Maintenant que les conteneurs sont "pulled", ils sont disponibles dans notre environnement et nous pouvons les monter, c'est à dire les utiliser.

Cependant, nous devons prendre en compte le fait que le conteneur partage le hardware avec l'OS hôte. Il faut donc réaliser, dans certains cas, un mapping avec les éléments hardware utilisés. Nous utiliserons donc la commande -p pour mapper un port réseau du host sur le port virtuel du conteneur.

Pour cela, nous allons démarrer docker en indiquant de mapper le port 3000 de la machine hôte sur le port 3000 du conteneur :

docker run -d --name=grafana -p 3000:3000 grafana/grafana

Le résultat de la commande précédente devrait vous permettre d'accéder à l'application grafana en vous connectant à l'URL suivante : 127.0.0.1:3000

Notez le "sens" de lecture de la commande -p : "-p container_port_number:host_port_mapped". Le premier "3000" de notre commande indique le port du conteneur et le second celui de votre machine hôte. Par exemple, la même commande avec le mapping -p 3000:6000 sollicitera le port 6000 de la machine hôte, et l'URL d'accès devient 127.0.0.1:6000.

NB: SI vous utilisez une machine virtuelle pour démarrer vos conteneur, comme préconisé dans l'article, pensez également à assurer le mapping des ports entre la VM docker et l'hôte de virtualbox. Dans VirtualBox, ouvrez le menu Configuration > Network > Advance > Port Redirection et assurez de récupérer le port que vous avez positionné en hôte dans la commande docker.

Qu'est-ce que TabNine​

TabNine est le complément de développement ultime, offrant des suggestions de code en temps réel pour vous aider à atteindre la perfection en un rien de temps. Et avec une installation facile sur Visual Studio Code, vous pouvez commencer à jouer votre symphonie de code en un rien de temps.

TabNine est un virtuose de la programmation, comprenant le contexte de votre code pour vous suggérer les meilleures lignes de code. Cela peut vous aider à éviter les erreurs courantes et à écrire du code plus efficace. Par exemple, si vous écrivez un morceau de code pour itérer sur une liste, TabNine peut vous suggérer les meilleures options pour parcourir cette liste, comme la boucle "for" ou la méthode "map".

TabNine est également un compositeur de génie, toujours à jour avec les dernières tendances en matière de développement. Cela signifie que vous pouvez compter sur TabNine pour vous offrir les meilleures suggestions, peu importe la version de votre langage de programmation. Et avec Visual Studio Code, vous avez un environnement de développement complet pour jouer votre symphonie de code.

Installer TabNine​

Pour utiliser TabNine avec Visual Studio Code, il suffit de suivre ces étapes simples :

• Ouvrir Visual Studio Code et accéder à la section Extensions.
• Rechercher TabNine dans la liste des extensions disponibles.
• Cliquer sur Installer pour planner l'extension.
• Une fois l'installation terminée, cliquer sur Activer pour démarrer l'utilisation de TabNine.
• Pour utiliser TabNine, il suffit de commencer à taper du code et de sélectionner une suggestion de code de l'extension.

Une fois installé, vous devrez créer un compte TabNine pour profiter de toutes les fonctionnalités de cet outil de développement. Cela ne prend que quelques minutes et vous permettra de bénéficier de toutes les suggestions en temps réel et des mises à jour constantes de TabNine. Alors n'attendez plus et ajoutez TabNine à votre environnement de développement Visual Studio Code aujourd'hui !

TabNine et Visual Studio Code sont les instruments de développement parfaits pour composer votre symphonie de code. Avec des suggestions en temps réel, une compréhension contextuelle, des mises à jour constantes et un environnement de développement complet, vous pouvez créer des morceaux de développement épiques en un rien de temps. Alors, n'attendez plus et laissez votre passion pour la programmation s'exprimer avec TabNine et Visual Studio Code.

Qu'est-ce que c'est ?​

Un Dockerfile est un document texte qui contient toutes les commandes qu'un utilisateur pourrait appeler sur la ligne de commande pour assembler une image. À l'aide de docker build, les utilisateurs peuvent créer une construction automatisée qui exécute successivement plusieurs instructions en ligne de commande.

Tout comme Vagrant qui utilise un fichier vagrant pour créer et personnaliser une machine virtuelle selon vos besoins, Docker utilise un fichier docker pour créer et personnaliser un conteneur ! Ils peuvent se ressembler mais ils sont très différents ! (vous pouvez apprendre comment utiliser Vagrant pour créer une machine virtuelle Windows Server ici)

Comme mentionné précédemment, pour cet exemple, nous allons créer un conteneur ruby avec mdl installé. Nous devons donc lancer notre fichier docker :

FROM ruby:latest

FROM crée une couche à partir de l'image Docker ruby latest.

FROM ruby:latest

WORDIR /mdl

L'instruction WORDIR définit le répertoire de travail pour toutes les instructions RUN, CMD, ENTRYPOINT, COPY et ADD qui la suivent dans le Dockerfile. Si le répertoire WORKDIR n'existe pas, il sera créé même s'il n'est pas utilisé dans une instruction Dockerfile ultérieure.

FROM ruby:latest

WORDIR /mdl
RUN gem install mdl

RUN a 2 formes :

• Commande RUN (forme shell, la commande est exécutée dans un shell, qui par défaut est /bin/sh -c sous Linux ou cmd /S /C sous Windows)
• RUN ["executable", "param1", "param2"] (forme exec)

Dans notre exemple, RUN exécute une commande qui installe MDL directement dans le conteneur ruby

FROM ruby:latest

WORDIR /mdl
RUN gem install mdl

ENTRYPOINT [ "/bin/bash" ]

ENTRYPOINT, comme RUN, a 2 formes ! La forme Shell ou la forme exec.

La forme exec, qui est la forme préférée :

ENTRYPOINT ["exécutable", "param1", "param2"]

La forme shell :

ENTRYPOINT commande param1 param2

Dans notre cas, nous l'utilisons sous la forme exec pour pouvoir exécuter notre bash. Cela laissera notre conteneur ouvert car bash s'exécute en arrière-plan.

Donc, maintenant que nous avons notre fichier docker, nous devons construire notre conteneur afin de l'exécuter !

docker build --tag user/mdl

La commande ---tag nomme l'image du conteneur en question. Et maintenant que le conteneur est construit, nous pouvons l'exécuter !

Pour cela, nous utiliserons la commande suivante :

docker run -tid --name mdl -v /home/vagrant:/mdlfiles user/mdl

Pour être sûr que votre conteneur fonctionne correctement, faites un simple "docker ps -a" juste pour avoir une confirmation. Cette opération vous montrera tous les détails et le statut de votre conteneur.

Après avoir confirmé que le conteneur est opérationnel, nous voulons exécuter mdl pour vérifier notre fichier markdown. Pour ce faire, nous devons exécuter la commande mdl dans un bash qui récupérera le fichier .md dans le dossier que nous avons partagé et nommé "mdlfiles".

docker exec mdl bash -c "mdl /mdfile/myfile.md"

Si vous avez quelques incohérences par rapport aux règles de l'outil mdl, vous obtiendrez un résultat comme celui-ci :

/mdfile/docker.md:5: MD009 Trailing spaces
/mdfile/docker.md:77: MD009 Trailing spaces
/mdfile/docker.md:25: MD012 Multiple consecutive blank lines
/mdfile/docker.md:51: MD012 Multiple consecutive blank lines
/mdfile/docker.md:13: MD013 Line length
/mdfile/docker.md:52: MD013 Line length
/mdfile/docker.md:54: MD013 Line length
/mdfile/docker.md:89: MD024 Multiple headers with the same content
/mdfile/docker.md:19: MD026 Trailing punctuation in header
/mdfile/docker.md:26: MD026 Trailing punctuation in header

Après les avoir tous corrigés, vous ne devriez plus avoir de retour après votre commande ! :)

Avant de commencer​

Assurez-vous d'avoir consulté mon précédent article sur Docker, car je vais y faire référence et il sera plus facile de suivre cet article :)

Dans ce cas, nous allons utiliser un conteneur ruby pour installer notre outil mdl. Vous avez montré comment configurer un conteneur ruby dans le précédent article sur docker.

Markdown Lint​

Il s'agit d'un outil pour les fichiers markdown (md) qui comprend une bibliothèque de règles pour encourager les normes et la cohérence des fichiers markdown et qui confirme si les fichiers suivent ces règles.

Container ruby​

Donc, pour commencer, exécutons le conteneur ruby ! Copiez-collez la ligne suivante dans votre terminal :

docker run -tid -v /home/vagrant:/mdfiles --name ruby --entrypoint=/bin/bash ruby:latest

Ok, donc vous regardez cette ligne de commande et vous vous demandez ce que c'est que tout ça !? Eh bien, laissez-moi vous expliquer :)

Le -tid est 3 choses différentes :

-t ou --tty : Allouer un pseudo-TTY -i ou --interactive : Garde STDIN ouvert même si non attaché -d ou --detach : Mode détaché : exécuter la commande en arrière-plan Ensuite, nous faisons un -v pour volume, qui dans notre cas, est utilisé pour refléter le dossier où nous avons notre fichier .md. Cela nous permettra d'avoir "le même dossier" dans notre conteneur. Rappelez-vous que le / est la racine et ensuite nous créons un nouveau dossier dans le conteneur nommé "mdfiles".

Then we use the --name and as the name suggest it's to attibute a name to your container.

Ensuite, nous utilisons l'option --name qui, comme son nom l'indique, permet d'attribuer un nom à votre conteneur.

Nous exécutons --entrypoint /bin/bash pour laisser un bash ouvert. Cela permet au conteneur de rester ouvert (up) au lieu de se fermer juste après l'exécution. Quand vous faites un exec, il ne va pas sur bash (exec est sh et pas bash). C'est pourquoi nous devons faire tourner le conteneur en bash, pour pouvoir utiliser toutes les commandes bash.

La différence entre docker run et docker exec est que docker exec exécute une commande sur un conteneur en cours d'exécution. D'autre part, docker run crée un conteneur temporaire, exécute la commande dans celui-ci et arrête le conteneur lorsque la commande est terminée. Nous utilisons donc --entrypoint pour lancer un conteneur et le laisser ouvert jusqu'à ce que nous décidions de l'arrêter.

Vous pouvez également donner une commande à votre conteneur directement en faisant cela : Note : Si vous avez un conteneur windows vous utilisez powershell au lieu de bash

docker exec ruby bash -c "ip add"

Nous exécutons le terminal bash avec la commande (-c) "ip add" Cela vous montrera l'adresse IP de votre conteneur ruby.

Et maintenant nous pouvons installer l'outil mdl :

docker exec ruby bash -c "gem install mdl"

Super, tout est beau et propre ! Maintenant, prenez un fichier .md de votre choix, et lancez mdl :

docker exec ruby bash -c "mdl /mdfiles/myfile.md"

Cela fera tourner l'outil mdl à travers votre fichier md et vous informera du nombre d'erreurs que vous avez, les lignes qu'elles sont et quelle était la règle qui n'a pas été respectée.

Si ça vous intrigue, suivez le guide !

[Mise à jour] Typora n'est pas un outil libre, et seule la version bêta semble gratuite. Pour éviter tout risque d'adaptation à un logiciel ultérieurement payant, nous proposons d'utiliser un clone libre de typora: MarkText.

Typora MarkText, par amour du markdown​

Cet outil s'appelle typora, et le site officiel est là: typora MarkText

Je vous présente cet outil que je vais tester pour la série d'article autour de gitlab CI/CD.

Il est disponible pour Windows, Linux, et Mac OS.

Des fonctionnalités pour profiter de la puissance du markdown​

Les fonctionnalités de l'éditeur permettent de profiter de la puissance du format markdown, car il est à la fois possible de sauvegarder des fichiers directement en markdown, mais également de copier le texte au format markdown.

Un éditeur wysiwyg​

Voici, par exemple, le rendu de cet article (dans sa version française)

Il suffit donc d'appliquer aux textes les formats souhaités (Titre 1-2-3, gras, italiques, etc. ) en le sélectionnant dans le menu, ou en utilisant les raccourcis habituels (CTRL+B, CTRL+I)

Sauvegarder au format MD​

Il suffit de sauvegarder le fichier, et Typora vous propose deux formats d'enregistrement: .md ou .txt. MarkText ne propose que le .md.

Exporter le contenu au format MD​

Typora MarkText propose une fonctionnalité très intéressante: l'export au format markdown.

Ainsi, si j'exporte le contenu de l'article (dans sa version française, toujours):

Un éditeur WYSIWYG pour éditSauvegarder au format MDer des fichiers Markdown ?

Si ça vous intrigue, suivez le guide !

# Typora, par amour du markdown

C'est outil s'appelle typora, et le site officiel est là: [typora](https://typora.io/)

Je vous présente cet outil que je vais tester pour la série d'article autour de gitlab CI/CD.

Il est disponible pour Windows, Linux, et en version beta (à l'heure d'acriture de ces lignes) pour Mac OS.

## Des fonctionnalités pour profiter de la puissance du markdown

Les fonctionnalités de l'éditeur permettent de profiter de la puissance du format markdown, car il est à la fois possible de sauvegarder des fichiers directement en markdown, mais également de copier le texte au format markdown.

### Un éditeur wysiwyg

Voici, par exemple, le rendu de cet article (dans sa version française)

Il suffit de sélectionner la partie que l'on souhaite exporter, puis utiliser l'entrée du menu ou d'appliquer le raccourci dédié: CTRL + MAJ + C (raccourci valable sus typora et sous MarkText)

La correction orthographique sur des fichiers Markdown​

Cette fonctionnalité ne mérite pas d'être détaillée, je suppose.

La qualité du Markdown​

Nos article sont soumis, avant build du site par Hugo, à mardownlint, un utilitaire permettant de valider la syntaxe markdown. Le présent article obtient le résultat suivant:

$ mdl content/posts/*.md --ignore-front-matter --rules ~MD013,~MD026,~MD033
content/posts/typora_fr.fr.md:13: MD009 Trailing spaces
content/posts/typora_fr.fr.md:15: MD009 Trailing spaces
content/posts/typora_fr.fr.md:21: MD009 Trailing spaces
content/posts/typora_fr.fr.md:23: MD009 Trailing spaces
content/posts/typora_fr.fr.md:27: MD009 Trailing spaces
content/posts/typora_fr.fr.md:39: MD009 Trailing spaces
content/posts/typora_fr.fr.md:45: MD009 Trailing spaces
content/posts/typora_fr.fr.md:47: MD009 Trailing spaces
content/posts/typora_fr.fr.md:50: MD009 Trailing spaces
content/posts/typora_fr.fr.md:52: MD009 Trailing spaces
content/posts/typora_fr.fr.md:58: MD009 Trailing spaces
content/posts/typora_fr.fr.md:60: MD009 Trailing spaces
content/posts/typora_fr.fr.md:64: MD009 Trailing spaces
content/posts/typora_fr.fr.md:75: MD009 Trailing spaces
content/posts/typora_fr.fr.md:81: MD009 Trailing spaces
content/posts/typora_fr.fr.md:82: MD009 Trailing spaces
content/posts/typora_fr.fr.md:84: MD009 Trailing spaces
content/posts/typora_fr.fr.md:96: MD009 Trailing spaces
content/posts/typora_fr.fr.md:100: MD009 Trailing spaces
content/posts/typora_fr.fr.md:109: MD009 Trailing spaces
content/posts/typora_fr.fr.md:35: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:36: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:90: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:91: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:105: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:106: MD012 Multiple consecutive blank lines

La qualité des fichiers produits est très bonne. Seules les erreurs d'espace de fin de ligne et de multiples lignes blanches (visible depuis la version wysiwyg, donc) sont à considérer lors de la saisie.

Les usages​

Les articles de site Hugo​

Pour gérer nos articles, typora MarkText est très utile. En création, il suffit de sauvegarder le fichier quelque part, et de l'ajouter directement depuis l'interface web de gitlab.

En modification, idem. Il suffit d'éditer l'article depuis gitlab, puis utiliser la fonction de copie au format MD, puis d'export au format MD.

Pour une utilisation plus poussée, il est possible de gérer le dossier d'article du site directement depuis typora, mais sans qu'il soit possible de gérer le dépôt git (à ma connaissance):

En déportant l'usage de git avec le terminal, typora MarText peut tout à fait servir à gérer les articles d'un blog utilisant les moteurs Hugo ou Jekyll.

Nos utilitaires​

Nos utilitaires s’appuient tous sur le format Markdown:

• nos wikis;
• les readme de nos développements;
• notre KB;
• nos ADR

L'outil d'export au format mardkown permet d'éditer les textes sous typora MarkText, et ainsi ne plus se préoccuper de la syntaxe, tout en bénéficiant de la possibilité d'éditer directement au format markdown si nécessaire (lors d'une revue de la structure d'un article, par exemple).

Conclusion​

Au départ de la série d'article sur gitlab CI/CD, je pense que je préfère encore utiliser la syntaxe MD directement, plutôt qu'un éditeur WYSIWIG.

Néanmoins, à l'usage, c'est séduisant. Il n'est pas impossible que la série d'articles qui arrive ne me fasse changer d'opinion !

Chocolatey​

Chocolatey est un module pour Windows permettant d'installer des paquets (outils) sur la machine. Aussi connu comme un outil de gestion de logiciels.

Il nous permet d'effectuer diverses tâches via la ligne de commande.

Par exemple, "choco install tool" est l'équivalent de "apt install tool" sur Ubuntu.

Pour l'installer, vous devez donc copier-coller cette ligne de commande dans votre terminal :

config.vm.provision "shell", inline: <<-SHELL

  Set-ExecutionPolicy Bypass -Scope Process -orce; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

SHELL

Cette commande installera chocolatey et vous permettra d'utiliser "choco install" pour installer d'autres outils dans votre machine Windows tels que Git ou VSCode.

Exemple​

Tu veux installer certains outils dont tu as besoin et pour ce faire, tu vas utiliser Chocolatey !

Donc, dans votre terminal, tapez l'une des commandes suivantes :

choco install git -y
choco install vscode -y
choco install hugo -y

Ces commandes installeront les outils respectifs, mais vous pouvez installer les outils dont vous avez besoin. La seule chose dont vous avez besoin est choco install "tool that you want" :) Notez, que le -y est pour répondre Oui aux questions posées par le processus d'installation ;

Bonjour à tous, le but de ce billet est d'expliquer comment gérer les fonctionnalités de Windows à l'aide des playbooks Ansible ;

Pour commencer, essayons de comprendre de quoi il s'agit. Nous voulons installer une fonctionnalité de Windows dans notre machine/vm et nous voulons le faire en utilisant Ansible pour automatiser toutes les installations et les ajouts.

Pour le faire en utilisant Ansible, nous devons utiliser des modules Ansible ! Et, dans ce cas, nous voulons utiliser le module win_feature. Mais qu'est-ce qu'un module ? Voyons voir :

Modules​

Les modules Ansible sont des scripts réutilisables et autonomes qui peuvent être utilisés par l'API Ansible, ou par les programmes ansible ou ansible-playbook.

Nous pouvons utiliser les modules pour installer, copier, déplacer, télécharger et beaucoup d'autres actions. Il y a aussi beaucoup de modules différents, et je veux dire beaucoup !

Ansible a des modules pour le Cloud, les bases de données, le réseau, la surveillance, Windows, presque tout ce que vous pouvez imaginer !

Mais pour ce post, nous allons nous concentrer uniquement sur un module Windows spécifique fourni par Ansible qui est le module win_feature.

Notez que ce n'est qu'un aperçu rapide de ce que sont les modules ! Vous pouvez consulter la documetation officielle d'Ansible sur les modules pour avoir une analyse plus approfondie.

win_feature​

Ce module installe ou désinstalle les rôles ou fonctionnalités de Windows sur Windows Server.

Mais, pour savoir quelle fonctionnalité nous voulons installer, nous devons trouver son nom. Pour cela, nous utiliserons une commande qui listera toutes les fonctionnalités avec l'information supplémentaire si elles sont installées ou non.

Tapez donc dans votre terminal la commande suivante :

Get-WindowsFeature

Vous devriez obtenir une liste complète des caractéristiques :

PS C:\> Get-WindowsFeature

Display Name                                            Name                       Install State
------------                                            ----                       -------------
[ ] Active Directory Certificate Services               AD-Certificate                 Available
    [ ] Certification Authority                         ADCS-Cert-Authority            Available
    [ ] Certificate Enrollment Policy Web Service       ADCS-Enroll-Web-Pol            Available
    [ ] Certificate Enrollment Web Service              ADCS-Enroll-Web-Svc            Available
    [ ] Certification Authority Web Enrollment          ADCS-Web-Enrollment            Available
    [ ] Network Device Enrollment Service               ADCS-Device-Enrollment         Available
    [ ] Online Responder                                ADCS-Online-Cert               Available

(...)

[X] Web Server (IIS)                                    Web-Server                     Installed
    [X] Web Server                                      Web-WebServer                  Installed
        [X] Common HTTP Features                        Web-Common-Http                Installed
            [X] Default Document                        Web-Default-Doc                Installed
            [X] Directory Browsing                      Web-Dir-Browsing               Installed
            [X] HTTP Errors                             Web-Http-Errors                Installed
            [X] Static Content                          Web-Static-Content             Installed
            [X] HTTP Redirection                        Web-Http-Redirect              Installed
            [X] WebDAV Publishing                       Web-DAV-Publishing             Installed
        [X] Health and Diagnostics                      Web-Health                     Installed
            [X] HTTP Logging                            Web-Http-Logging               Installed
            [X] Custom Logging                          Web-Custom-Logging             Installed
            [X] Logging Tools                           Web-Log-Libraries              Installed
            [X] ODBC Logging                            Web-ODBC-Logging               Installed
            [X] Request Monitor                         Web-Request-Monitor            Installed
            [X] Tracing                                 Web-Http-Tracing               Installed
        [X] Performance                                 Web-Performance                Installed
            [X] Static Content Compression              Web-Stat-Compression           Installed
            [X] Dynamic Content Compression             Web-Dyn-Compression            Installed


(...)

[X] .NET Framework 4.7 Features                         NET-Framework-45-Fea...        Installed
    [X] .NET Framework 4.7                              NET-Framework-45-Core          Installed
    [ ] ASP.NET 4.7                                     NET-Framework-45-ASPNET        Available
    [X] WCF Services                                    NET-WCF-Services45             Installed
        [ ] HTTP Activation                             NET-WCF-HTTP-Activat...        Available
        [ ] Message Queuing (MSMQ) Activation           NET-WCF-MSMQ-Activat...        Available
        [ ] Named Pipe Activation                       NET-WCF-Pipe-Activat...        Available
        [ ] TCP Activation                              NET-WCF-TCP-Activati...        Available
        [X] TCP Port Sharing                            NET-WCF-TCP-PortShar...        Installed

(...)

Maintenant, nous pouvons voir une liste complète de toutes les fonctionnalités de Windows (dans l'exemple ci-dessus, il n'y en a que quelques-unes) avec l'information supplémentaire si elles sont installées ou non.

Cela pourrait être un excellent moyen de voir quelles fonctionnalités vous devez ajouter à votre playbook.

Maintenant, laissez-moi vous montrer un moyen de savoir si une fonctionnalité dont vous connaissez déjà le nom est installée ou non.

Dans ce cas, nous allons rechercher la fonctionnalité .NET Framework. Nous allons vérifier le nom correct de la fonctionnalité et voir si elle est installée ou non.

Pour cela, nous allons utiliser la commande ci-dessous :

Get-WindowsFeature | Where-Object {$_. name-match ".Net"} | Format-List Name,DisplayName, Installstate | more

Le résultat sera le suivant :

Name         : Print-Internet
DisplayName  : Internet Printing
InstallState : Available

Name         : Web-Net-Ext
DisplayName  : .NET Extensibility 3.5
InstallState : Installed

Name         : Web-Net-Ext45
DisplayName  : .NET Extensibility 4.7
InstallState : Installed

Name         : Web-Asp-Net
DisplayName  : ASP.NET 3.5
InstallState : Installed

Name         : Web-Asp-Net45
DisplayName  : ASP.NET 4.7
InstallState : Installed

Name         : NET-Framework-45-ASPNET
DisplayName  : ASP.NET 4.7                             #As you can see the feature is available, therefore not installed
InstallState : Available

Name         : BitLocker-NetworkUnlock
DisplayName  : BitLocker Network Unlock
InstallState : Available

Name         : Internet-Print-Client
DisplayName  : Internet Printing Client
InstallState : Available

Name         : Telnet-Client
DisplayName  : Telnet Client
InstallState : Available

Name         : WAS-NET-Environment
DisplayName  : .NET Environment 3.5
InstallState : Available

Name         : Wireless-Networking
DisplayName  : Wireless LAN Service
InstallState : Available

Maintenant que nous avons confirmé le nom et l'état de l'installation, nous pouvons ajouter à notre playbook.yaml le module win_feature dont nous avons parlé plus tôt dans l'article.

Regardons le playbook.yaml contenant le module win_feature.

---
- name: Install Windows Features
  hosts: all
  tasks:
          - name: Install .Net Framework 4.5
            win_feature:
                    name: NET-Framework-45-ASPNET
                    state: present

Comme vous pouvez le voir, playbook.yaml installera la dernière fonctionnalité Windows de .Net Framework.

Cherchons la fonction .net Framework sur notre terminal et voyons ce qui a changé :

PS C:\> Get-WindowsFeature | Where-Object {$_. name-match "NET-Framework-45-ASPNET"} | Format-List Name,DisplayName, Installstate | more


Name         : NET-Framework-45-ASPNET
DisplayName  : ASP.NET 4.7
InstallState : Installed

Et voilà ! Nous avons installé avec succès une fonctionnalité Windows de notre choix en utilisant les playbooks Ansible !

Maintenant, c'est à vous de voir quelle fonctionnalité de Windows vous souhaitez installer sur votre serveur !

Rappelez-vous que vous pouvez faire un playbook installant autant de fonctionnalités que vous le souhaitez. J'espère que ce post vous aidera à comprendre un peu mieux le module win_feature :)

Pour commencer, regardons un simple vagrantfile contenant une boîte Windows Server 2019 :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

  SHELL

Ceci est juste pour vous donner un aperçu d'un fichier vagrant très simple contenant juste la boîte, le nom du vm, la mémoire RAM et un terminal shell prêt à fonctionner.

C'est parti !

Reload​

A quoi sert la recharge ?

Eh bien, utiliser reload dans votre fichier vagrant revient à faire un reboot de votre machine ;

Donc, mettons cela dans le contexte ;

Disons que nous avons installé Chocolatey et que nous voulons l'utiliser pour installer git.

C'est facile, mais nous ne pouvons pas le faire tout de suite parce que, comme la machine virtuelle n'a pas été rechargée (redémarrée), elle ne peut pas prendre en compte la modification effectuée précédemment ;

Donc, pour résoudre ce problème, nous devons ajouter un reload provisioner à notre vagrantfile !

config.vm.provision :reload

La commande ci-dessus est ce que nous devons ajouter à notre fichier vagrant mais nous ne pouvons pas l'utiliser si elle n'est pas installée.

Donc, pour installer le porvisioner reload, ouvrez un terminal Powershell et tapez :

vagrant plugin install vagrant-reload

Ceci va installer le plugin qui vous permettra d'utiliser le reload provisioner sur notre vagrantfile ;

Vous vous souvenez de notre simple fichier vagrant ? Voyons à quoi ressemble le fichier vagrant avec l'installation de Chocolatey :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

  SHELL

Dans notre fichier vagrant ci-dessus, nous installons Chocolatey. Mais, rappelez-vous, nous voulons l'utiliser pour installer nos outils et sans recharger le vm cela ne sera pas possible !

Ce que nous allons faire, c'est recharger la machine après avoir installé Chocolatey et après le rechargement, nous allons ouvrir un nouveau terminal Shell provisioner afin d'installer Git en utilisant Chocolatey ;

Jetons un coup d'oeil à notre fichier vagrant et voyons comment tout cela fonctionne :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

  SHELL

  config.vm.provision :reload

  config.vm.provision "shell", inline: <<-SHELL

    choco install git -y

  SHELL

Super ! Nous avons réussi l'installation du plugin et le rechargement de notre vm !

Disk Size​

Un autre plugin utile est le Disk Size !

Ce plugin nous permettra de gérer la taille du disque de notre vm (tous ceux qui utilisent Vagrant savent que c'est une question importante :) ).

Comme vu précédemment, nous devons d'abord installer le plugin directement sur notre machine afin de pouvoir l'utiliser dans notre fichier vagrant.

Donc, copiez-collez ce qui suit :

vagrant plugin install vagrant-disksize

Voyons ce que ça donne :

config.disksize.size = '40GB'

Comme vous pouvez le voir, je veux avoir un disque de 40 Go. Mais où le placer ? Jetons un coup d'oeil à un fichier vagrant de base :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

Vagrantfile très simple et basique mais il manque quelque chose ! Où est la taille du disque ?

Eh bien, puisque c'est une partie de la configuration du vm, nous allons la placer juste après la boîte du vm :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"
  wvm.disksize.size = "40GB"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

Et voilà ! Vous pouvez maintenant créer des vm's avec la taille de disque que vous souhaitez :)

NOTE : Si vous démarrez votre vm et voyez que votre vm windows n'a pas la taille de disque que vous avez attribué et n'a probablement que jusqu'à 20gb de taille de disque.

Le reste n'est pas attribué à la bonne partition. Pour corriger cela nous allons taper la commande suivante dans un Powershell à l'intérieur de la VM : (n'oubliez pas à la fin de la ligne de commande d'ajouter vos GB, dans mon cas j'ai donné 40gb donc je vais mettre 39 à la fin de la commande)

Resize-Partition -DriveLetter C -Size 39gb

A bientôt sur le prochain post :)

C'est assez désagréable d'avoir trouvé LE thème parfait, et qu'une simple fonctionnalité lui manque. J'ai donc décidé de "ruser", et d'utiliser la gestion native des taxonomies, afin d'inscrire plusieurs auteurs sur un blog. Et pour le coup, ça fonctionne plutôt pas mal.

Pour rédiger cet article, je me suis inspiré du tutoriel suivant : How to create author pages.

Je prends soin de le compléter uniquement sur les points pour lesquels j'ai du expérimenter un tas de choses.

Usages des taxonomies​

Il y a deux taxonomies en standard dans Hugo :

• Les tags ;
• Les catégories.

Pour utiliser les taxonomies standard d'Hugo, ou celles natives du thème choisi, c'est très simple, il suffit d'ajouter à votre archetype les éléments suivants :

---
tags:
- faire son site
- hugo-tips
categories:
- hugo
---

Le principe est donc simple : dès lors que vous ajoutez une catégorie ou un tag, et que le thème le gère bien, vous retrouvez une page http://[votresite]/tags/ et une autre /catégories/ qui listent les tags et catégories, et une page par item listant les articles qu mentionnent l'item dans leurs archétypes.

Voyons maintenant comment créer une nouvelle taxonomy qui ouvrirait la possibilité d'ajouter un ou plusieurs auteurs à un article.

Créer une taxonomie​

A chaque taxonomy correspond deux templates :

• list.html, qui correspond au template de la page qui décrira un des items (un auteur, pour nous, et tous les articles qui lui sont liés)
• terms.html, qui correspond à la page qui va lister tous les éléments d'une taxonomy (tous les auteurs, donc)

Dans notre cas, nous allons créer une taxonomie d'auteur. Il s'agira d'auteur de post, et non d'auteur de livres, comme dans l'exemple du lien précédent.

Nous allons travailler dans deux arborescences :

• le dossier content, logiquement à la racine du site hugo ;
• le dossier layout du thème utilisé par le site.

Les données concernant les items de la taxonomie​

Dans le dossier content, nous allons créer un dossier par auteur, dans lequel sera positionné un fichier _index.md,

content
└── authors/
    ├── j0rdan-m/
    │   └── _index.md
    └── author-2/
        └── _index.md

Chaque _index.md décrit un auteur, et se compose comme suit :

---
name: j0rdan-m
photo: 'https://j0rdan-m.gitlab.io/blog/pearlbonnet.png'
twitter: '@j0rdan_m'
---
j0rdan is an author of the blog

Les méta-données​

Les datas concernant les auteurs sont prêtes, il faut maintenant paramétrer les méta-datas.

Pour cela, il va falloir créer un dossier authors dans le layout de notre thème (et pas le dossier des taxonomies, ce qui peut surprendre).

my_theme/
└── layout/
    └── authors/
        └── list.html
        └── terms.html

Le fichier list.html ne liste pas les auteurs, mais les articles qui mentionnent les auteurs (ou tout autre choix de taxonomie).

Ainsi, voici le contenu basique du fichier list.hml :

<h1>{{ .Params.name }}</h1>
<img src="{{ .Params.photo }}" alt=""/>

<h2>Bio</h2>
{{ .Content }}
{{ with .Params.twitter }}
  <p>
    <a href="https://twitter.com/{{ substr . 1 }}">
      Follow {{ $.Params.name }} on Twitter
    </a>
  </p>
{{ end }}

<h2>Articles</h2>
<ul>
{{ range .Data.Pages }}
    <li><a href="{{ .Permalink }}">{{ .Title }}</a></li>
{{ end }}
</ul>

Le fichier terms.html est le template de la page qui va recenser tous les auteurs, et proposer un lien pour chacun :

<h1>Authors</h1>
<ul>
{{ range .Data.Pages }}
  <li><a href="{{ .Permalink }}">{{ .Params.name }}</a></li>
{{ end }}
</ul>

Attention, il faudra intégrer en amont et aval des codes proposés le contenu du thème, en prenant example sur la page par défaut (probablement dans themes/my_theme/layouts/_default/single.html)

Le thème utilisé par ce blog proposait un beau commentaire pour isoler les infos de thème du contenu (grâce à la balise <section></section>. Un autre thème que j'utilise mentionne, lui

Puisque nous sommes sur cette page single.html, nous allons pouvoir y ajouter une mention de l'auteur :

{{- range .Params.authors }}
  {{- with $.Site.GetPage "taxonomyTerm" (printf "authors/%s" (urlize .)) }}
    <figure>
      <img src="{{ .Params.photo }}" alt=""/>
      <figcaption>
        <a href="{{ .Permalink }}">{{ .Params.name }}</a>
      </figcaption>
    </figure>
  {{ end }}
{{ end }}

Cette mention est à ajouter à l'endroit de la page où vous souhaitez la faire apparaitre, évidemment.

Enfin, maintenant que tout est prêt, nous allons pouvoir déclarer la taxonomie dans notre fichier config.toml, en y ajoutant la pention suivante :

[taxonomies]
  author = "authors"
  tag = "tags"
  category = "categories"

A titre personnel, j'ai ajouté manuellement une entrée dans le menu, sachant que l'adresse de visualisation de votre taxonomie sera : http://[mon site]/authors/

Voilà donc comment, grâce aux taxonomies, ce blog est devenu un blog multi-auteurs.

Before we start, Plugins!​

Installation​

Windows​

Ainsi, pour mettre en action certains plugins dans notre fichier Vagrant, nous devons les installer directement dans notre terminal.

Pour ce faire, ouvrez un Powershell et installez les plugins suivants (notez que ce plugin est pour Windows OS) :

vagrant plugin install vagrant-reload

Cela nous permettra de recharger notre vm pendant la création du vm.

Autres OS​

Maintenant, nous voulons utiliser les fonctionnalités de Windows mais nous utilisons un Linux ou un MacOS.

Pour cela, nous devons installer les plugins suivants dans notre machine Linux ou MacOS :

vagrant plugin install vagrant-reload
vagrant plugin install winrm
vagrant plugin install winrm-fs
vagrant plugin install winrm-elevated

Cela nous permettra de recharger notre vm et d'utiliser les fonctionnalités de Windows avec vagrant ;

Maintenant que nous avons installé nos plugins, continuons ;

WSL​

Qu'est-ce que WSL et qu'est-ce qu'il fait ? WSL est l'abréviation de Windows Subsystem for Linux et, en l'installant sur notre serveur Windows, il nous permettra, en gros, d'avoir Linux sur un terminal Windows.

Cela signifie que vous pouvez, par exemple, installer un outil dans votre machine virtuelle Windows en utilisant des commandes Linux comme wsl sudo apt ansible -y (cette commande installera Ansible dans votre machine virtuelle Windows).

Mais pour utiliser WSL, nous devons l'installer ! Et pour l'installer, nous allons utiliser Vagrant. Jetons un coup d'oeil à notre fichier Vagrant :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

  SHELL

end

Si ce fichier vagrant vous semble familier, il devrait l'être ! Il s'agit du fichier vagrant de notre post précédent où nous avons défini la configuration de notre machine et installé Chocolatey.

Maintenant, ce que nous voulons faire, c'est installer WSL et pour ce faire, nous devons ajouter la commande d'installation dans notre Shell provisioner.

Donc, copiez-collez ceci dans le terminal shell de votre vagranfile :

Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

Donc, notre fichier vagrant devrait ressembler à ceci pour le moment :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

  SHELL

end

Ainsi, nous avons maintenant WSL installé dans notre vm Windows Server ! C'est génial et nous avons maintenant la liberté de l'utiliser à volonté !

Depuis que nous avons installé Chocoaltey et WSL, nous voulons être sûrs que la machine prend en compte les modifications appliquées.

Pour cela, nous allons utiliser un provisioner (shell) reload :

  config.vm.provision :reload

Nous allons l'ajouter après notre provisionneur de shell comme ceci :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

  SHELL

  # trigger reload
  config.vm.provision :reload

end

Maintenant que notre provisioner est rechargé, nous pouvons installer Kali Linux (distribution Linux basée sur Debian).

Pour cela, nous allons ouvrir un autre termninal et utiliser chocolatey pour l'installer.

Juste après avoir installé Kali Linux, nous allons recharger notre provisioner une fois de plus.

Cela nous donnera la certitude que tout a été redémarré, y compris la machine virtuelle elle-même !

Donc, voyons ce que nous devons ajouter :

  # execute code after reload
  config.vm.provision "shell", inline: <<-SHELL
    choco install wsl-kalilinux -y
  SHELL

  # trigger reload
  config.vm.provision :reload

Et maintenant que tout est frais et propre, ouvrons un autre terminal shell et commençons à utiliser WSL !

Pour commencer à utiliser WSL et voir si elle fonctionne, ajoutons un shell avec une simple mise à jour du paquet :

wsl sudo apt update

Plutôt facile, non ? Alors, voyons comment l'utiliser efficacement.

Pour l'essayer, installons quelques outils dont nous aurons besoin.

Installons Ansible et décompressons le paquet :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

  SHELL

  # trigger reload
  config.vm.provision :reload

  # execute code after reload
  config.vm.provision "shell", inline: <<-SHELL
    wsl sudo apt update
    wsl sudo apt install -y ansible
    wsl sudo apt install -y unzip
  SHELL
end

Pourquoi avons-nous besoin d'installer Ansible et Unzip, me direz-vous ? Eh bien, nous aurons besoin de décompresser certains fichiers, c'est pourquoi nous avons besoin de Unzip.

Pour Ansible, cela nécessite un peu plus d'explications, suivez-moi :)

Ansible​

Ansible est un moteur d'automatisation, qui fonctionne avec des fichiers .yml appelés playbooks, et qui automatise l'approvisionnement du cloud, la gestion de la configuration, le déploiement d'applications, l'orchestration intra-service et de nombreux autres besoins informatiques.

Il n'utilise pas d'agents ni d'infrastructure de sécurité personnalisée supplémentaire, il est donc facile à déployer et, surtout, il utilise un langage très simple (YAML, sous la forme de Playbooks Ansible) qui vous permet de décrire vos tâches d'automatisation d'une manière qui se rapproche de l'anglais courant.

Nous avons également un fichier hosts (également connu sous le nom d'Inventaire). C'est là que nous allons ajouter nos machines cibles sur lesquelles nous souhaitons exécuter les playbooks.

Allez voir le lien pour une information plus profonde et détaillée sur Ansible et ce qu'il fait.

Donc, pour utiliser Ansible, nous avons besoin d'un playbook fonctionnel, d'hôtes et d'un tas d'autres choses ! Et pour cela nous allons utiliser wget pour télécharger un fichier zip contenant tout cela (notre paquet unzip sera utile :D ).

Copiez-collez simplement ce fichier dans votre provisioner :

    wsl wget https://github.com/j0rdan-m/vagrant_wsl_ansible/archive/master.zip

Cela va télécharger le fichier zip.

Mais nous devons le décompresser :

    wsl unzip master.zip

Grâce à ce travail, nous disposons désormais de playbooks fonctionnels.

Mais avant de les vérifier, configurons notre fichier hosts. Nous allons simplement ajouter la machine localhost dans le fichier hosts avec un utilisateur, un mot de passe, une méthode de connexion et une configuration de port.

Si tout est correct, cela devrait fonctionner parfaitement avec vos playbooks.

    wsl sudo bash -c "echo [self] >> /etc/ansible/hosts"
    wsl sudo bash -c "echo 127.0.0.1 >> /etc/ansible/hosts"
    wsl sudo bash -c "echo [self:vars] >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_port=5985 >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_connection=winrm >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_winrm_transport=basic >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_user=vagrant >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_password=vagrant >> /etc/ansible/hosts"

Et, juste pour être sûr que tout est correct, faisons un ping à notre vm :

    wsl ansible self -m win_ping

Maintenant que le fichier hosts est correct, nous pouvons passer à nos playbooks !

Nous en avons 3 pour être exacts ! Un pour installer IIS, un pour installer quelques outils (Git, VSCode et SumatraPDF) et le dernier qui crée un utilisateur de service et lui donne les droits sur les bons dossiers.

Pour les utiliser, nous devons utiliser la commande ansible-playbook comme ceci :

    wsl ansible-playbook vagrant_wsl_ansible-master/tools.yml
    wsl ansible-playbook vagrant_wsl_ansible-master/iis.yml
    wsl ansible-playbook vagrant_wsl_ansible-master/users.yml

Cela lancera chaque livre de jeux dans l'ordre présenté.

Ainsi, notre playbook devrait ressembler à quelque chose comme ceci :

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

  SHELL

  # trigger reload
  config.vm.provision :reload

  # execute code after reload
  config.vm.provision "shell", inline: <<-SHELL
    choco install wsl-kalilinux -y
  SHELL

  # trigger reload
  config.vm.provision :reload

  # execute code after reload
  config.vm.provision "shell", inline: <<-SHELL
    wsl sudo apt update
    wsl sudo apt install -y ansible
    wsl sudo apt install -y unzip
    wsl wget https://github.com/j0rdan-m/vagrant_wsl_ansible/archive/master.zip
    wsl unzip master.zip
    wsl sudo bash -c "echo [self] >> /etc/ansible/hosts"
    wsl sudo bash -c "echo 127.0.0.1 >> /etc/ansible/hosts"
    wsl sudo bash -c "echo [self:vars] >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_port=5985 >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_connection=winrm >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_winrm_transport=basic >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_user=vagrant >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_password=vagrant >> /etc/ansible/hosts"
    wsl ansible self -m win_ping
    wsl ansible-playbook vagrant_wsl_ansible-master/tools.yml
    wsl ansible-playbook vagrant_wsl_ansible-master/iis.yml
    wsl ansible-playbook vagrant_wsl_ansible-master/users.yml

  SHELL

end

Nous avons maintenant une machine virtuelle Windows Server entièrement fonctionnelle avec Ansible et un tas d'autres trucs sympas dedans !

J'espère que cela vous a aidé et n'oubliez pas de consulter les autres articles ;)

Vagrant​

Voyons maintenant comment nous pouvons en créer un selon nos besoins et nos envies.

Tout d'abord, la VM. Nous avons décidé d'opter pour un système d'exploitation Windows Server 2019 et pour ce faire, nous avons cherché une boîte Windows Server sur le site vagrants box. Sur le site, il suffit de taper, dans le champ de recherche, le type de VM que vous recherchez (Linux, Windows, etc). Dans notre cas, il suffit de taper "mcree/win2019" et vous le trouverez. Dans la page de la boîte, vous trouverez "Vagrantfile" et "New". Ce qui nous intéresse dans cet article, c'est le "Vagrantfile". Comme vous pouvez le voir dans la page de l'encadré, il y a la configuration initiale du Vagrantfile. Vous en aurez besoin pour créer (up) votre machine serveur virtuelle. C'est le début de notre Vagrantfile :

Vagrant.configure("2") do |config|
  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"
end

Comme vous pouvez le voir, nous obtenons la boîte pour notre vm et sa version.

Maintenant, ajoutons le nom de notre vm et la quantité de mémoire (RAM) que nous voulons lui donner :

wvm.vm.provider "virtualbox" do |v|
  v.name = "Windows Server 2019"
  v.memory = "2048"
end

Maintenant que nous avons le nom de notre vm et la capacité de RAM, nous allons configurer le réseau :

wvm.vm.define "Windows Server 2019" do |web|
  web.vm.hostname = "winserver19"
  web.vm.network "public_network"
end

Ici, nous définissons le nom d'hôte du vm et le type de réseau que nous souhaitons donner au vm (public, privé, etc.).

Notez qu'il existe de multiples variantes de configuration de réseau, ce post ne vous montrera que la manière la plus basique de mettre votre vm en réseau ;

Et le fichier Vagrant devrait ressembler à quelque chose comme ceci maintenant :

Vagrant.configure("2") do |config|
  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  wvm.vm.define "Windows Server 2019" do |web|
    web.vm.hostname = "winserver19"
    web.vm.network "public_network"
  end
end

Il s'agit d'un fichier Vagrant très simple et facile (comme nous l'aimons) à configurer.

Mais nous voulons avoir quelques outils installés sur la machine virtuelle lorsque nous Up notre machine virtuelle. Pour ce faire, nous allons utiliser un terminal (shell).

Donc, nous devons ajouter au Vagrantfile le terminal :

config.vm.provision "shell", inline: <<-SHELL

SHELL

C'est le terminal qui va vous permettre de donner des commandes pour ajouter, supprimer, déplacer et un tas d'autres choses à la vm ;

Donc, nous allons installer Chocolatey (voir ci-dessous l'explication de ce qu'est Chocolatey et comment l'installer) et, en utilisant Chocolatey, nous allons installer Git, VSCode et Hugo ;

Notez que SHELL à la fin du terminal remplace la fin dans les autres configurations vues précédemment.

Chocolatey​

Chocolatey est un module pour Windows permettant d'installer des paquets (outils) sur la machine. Par exemple, "choco install tool" est l'équivalent de "apt install tool" sur Ubuntu. Pour l'installer, vous devez donc copier-coller cette commande dans votre shell provisioner vagrantfile :

config.vm.provision "shell", inline: <<-SHELL

  Set-ExecutionPolicy Bypass -Scope Process -orce; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

SHELL

Cette commande installera chocolatey et vous permettra d'utiliser "choco install" pour installer d'autres outils sur votre serveur Windows tels que Git ou VSCode.

Outils​

Maintenant, vous devez installer les outils dont vous avez besoin et pour ce faire, vous allez utiliser Chocolatey ! Donc, ajoutez à votre shell vagranfile les commandes suivantes :

choco install git -y
choco install vscode -y
choco install hugo -y

Ces commandes installeront les outils respectifs, mais vous pouvez installer les outils dont vous avez besoin. La seule chose dont vous avez besoin est choco install "tool that you want" :) Notez, que le -y est pour répondre Oui aux questions posées par le processus d'installation ;

Donc, notre fichier Vagrant semble être complet ! Voyons donc à quoi il ressemble avec tout ce qui a été installé :

Vagrantfile​

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  wvm.vm.define "Windows Server 2019" do |web|
    web.vm.hostname = "winserver19"
    web.vm.network "public_network"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -orce; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    choco install git -y
    choco install vscode -y
    choco install hugo -y

  SHELL

end

Voici comment je procède pour écrire des articles techniques, afin de les rendre lisibles, et utiles pour le futur moi qui veut se souvenir comment utiliser cette techno dont j'ai écrit un article il y a plusieurs mois.

Tu viens juste de lire l'introduction. Je commence par une introduction, car mon thème prend ce texte comme résumé dans la première page.

Voici le début de mon fichier taxonomies.md:

*archetype de posts*
--

Aujourd'hui, en français, je souhaite aborder le sujet des archétypes du moteur de génération de site Hugo. Ce moteur très performant est d'ailleurs utilisé pour générer ces pages.

<!--truncate-->

Certains thèmes comprennent la "balise more", donc elle termine mon intro.

Je peux terminer mon intro après le <!-- more --> si je pense qu'elle doit être complétée.

Titres​

Je continue le post en utilisant les titres. Je pense que les titres sont importants, car ils nous permettent de comprendre la structure de l'article, et permettent aux "utilisateurs expérimentés" d'aller directement à la section qui les intéresse.

Sur mon précédent article, sur les archétypes, mes titres étaient:

# archetypes/Default.md

(...)

# archetypes/mon_mien.md

(...)

J'aurais pu utiliser une structure plus complexe en utilisant le deuxième ou le troisième niveau de titres

# First level

## Second level

### Third level

Ce code apparaitra ainsi sur le blog :

First level​

blablabla

Second level​

blablabla expliqué

Third level​

blablabla détail

C'est important d'utiliser les titres sur vos tutos. Parfois, les lecteurs lisent plus d'un article en même temps, et il est plus facile pour eux de passer à la partie suivante lorsque les titres organisent la page.

Bout d'code​

Il existe deux types de méthodes pour mettre du code en markdown:

code dans un ligne de texte​

C'est quand tu utilises la balise "code" ``` 'my code is cool' ``` dans la même ligne que le texte que tu écris.

Isolement des lignes de codes​

Il s'agit de présenter son code ainsi :

```
my code is cool
```

Le code est alors isolé dans son propre paragraphe.

Mon avis sur la question​

Utilisez toujours le second. Pour une raison simple: les gens utilisent le copier/coller. Et il est tellement plus facile de copier coller un code sur une ligne isolée.

Astuces en vrac​

Bullet points​

• Ne pas
• les utiliser
• n'importe
• comment

Ne les utilisez que lorsque c'est pertinent, c'est à dire dans deux cas :

• Pour une lite de trucs
• Pour une liste de machins

Utiliser la balise "citation" pour les citations​

Utiliser les citations pour les citations. Je sais que ça sonne un peu stupide, mais tu pourrais vouloir utiliser le format "citation" pour autre chose parce qu'il est joli. Ne le fais pas.

Quote style is for quote - Dr. CssProvider

Ce post vous expliquera comment déployer une machine Ubuntu très facilement et rapidement !

Qu'est-ce dont vous avez besoin ?​

Nous utiliserons 2 outils pour rendre le déploiement de la vm Ubuntu très rapide !

Ces outils sont Vagrant et Virtual Box.

Installation​

Par téléchargement​

Notez que vous devez choisir le système d'exploitation où vous souhaitez installer l'outil (Linux, Windows, etc...)

• Vagrant -> téléchargez Vagrant

• Virtual Box -> téléchargez Virtualbox

En utilisant la gestion de paquets​

Windows - Chocolatey​

Pour commencer, vous devez installer Chocolatey. J'ai un post qui explique comment le faire correctement ici -> Maintenant que vous avez installé Chocolatey, utilisons-le. Commençons avec VirtualBox, utilisez donc la commande suivante :

choco install virtualbox

Et maintenant Vagrant :

choco install vagrant

Linux - apt​

C'est le même concept que choco install mais pour Linux bien sûr. Donc, pour Linux, nous utiliserons apt install. Pour VirtualBox :

sudo apt install virtualbox

Pour Vagrant :

sudo apt install vagrant

Déploiement​

Donc, premièrement nous avons besoin de la boîte Vagrant (n'oubliez pas de consulter le post Vagrant sur la page pour en apprendre un peu plus sur les boîtes Vagrant). Pour cet exemple, nous utiliserons Ubuntu 18.04 LTS

Maintenant, sur votre machine locale, accédez à votre terminal, créez un dossier pour votre box Vagrant et, à l'intérieur de votre nouveau dossier, tapez :

vagrant init ubuntu/bionic64

En faisant cela, vous ajouterez la box à votre Vagrant local. Et maintenant, créons notre machine virtuelle Ubuntu ! Tapez donc dans votre terminal :

vagrant up

Et voilà ! Votre première machine Ubuntu fraîche et propre !

Les archétypes sont les éléments qui permettent de générer les entêtes de page Hugo, lorsqu'on les créées avec la commande hugo new my_file.md.

archetypes/Default.md​

Le default.md présent dans l'archétype s'applique à tous les "new hugo" que vous allez créer. Ce default.md est personnalisable, comme vu dans l'article précédent, Gérer du contenu dans un site Hugo, mais il peut également être également multiplié.

archetypes/mon_mien.md​

Imaginons le cas d'un site d'ESN (au hasard ;) ), dans lequel on trouvera une page d'accueil, un certains nombre de page 'Produits', de page 'Offres' et une page 'blog'.

il suffira de créer, dans le folder archetypes, trois fichiers :

• produit.md
• offre.md
• post.md

ces trois fichiers contiendront les archétypes adequat en fonction du type de page.

Il est très simple d'appliquer un archétype à une page : l'archétype doit posséder le même nom que le répertoire hébergeant le type de page !

par exemple, pour créer une page produit, un page offre et un article de blog, nous utiliserons ces trois commandes :

# Nouvelle page produit
hugo new produit/eaviz.md

# Nouvelle offre Marte
hugo new offre/expert_ansible.md

# Nouvel article de blog
hugo new post/gestion_archetype.md

Gestion des thèmes​

A l'instar du config.toml de la section exampleSite d'un thème, je vous conseille vivement de repartir du ou des archetypes proposés par un thème. Ca permettra de connaitre les bons répertoires de travail pour voir apparaitre vos pages aux endroits prévus par le thème.

Le but de ce post est d'éclairer la manière de procéder pour faciliter la création de post.

*Disclaimer : le tutoriel officiel est très mauvais dans le cas d'un site que l'on souhaite déployer sous gitlab Pages !*

Gestion des pages​

Dans le cadre d'un site en mode blog, c'est relativement simple.

La commande hugo new <repertoire>/<nom d'article>.md permet d'ajouter des articles au format MD dans le dossier "répertoire". Usuellement, on utilisera "post" pour un blog.

Propriété d'un page​

Les propriétés d'une page se gèrent dans l'entête des pages créées. elle se retrouvent sous la forme suivante :

---
title: "mon article"
date: AAAA/MM/DD/THH:MM:SS
draft: true

Il s'agit du standard généré par Hugo. Deux éléments sont à noter :

1. Dans un déploiement dans gitlab, seule les pages "draft: false" s'affichent. Les pages "draft: true" sont ignorées lors du build du site. Il est alors possible de builder un site en local (avec l'option -D pour draft) et tester certaines pages tout en profitant de l'hébergement gitlab.
2. La version de base peut être complétée avec d'autres informations concernant la page créée :

• subtitle: pour ajouter un sous-titre
• tags: permet d'ajouter des tags à un article
• categories: permet de catégoriser les articles

Bref, rien de foufou, mais c'est utile. Ainsi, l'entête de l'article que vous êtes en train de lire est :

---
title: "Gérer du contenu dans un site Hugo"
date: 2020-04-14T09:39:30Z
draft: false
subtitle: "Comment gérer du contenu dans un site statique généré par Hugo"
tags:
- français
- hugo-tips
categories:
- hugo
---

Gestion des images​

Pour gérer les images affichées dans un article, voici la solution que je propose, et qui a l'avantage de marcher avec hugo en local, mais également avec un déploiement gitlab :

1. Créer un sous-dossier "images" dans le répertoire "content"
2. Y déposer les images que vous souhaitez faire apparaitre dans votre article
3. ajouter ![texte alternatif](../../images/mon_image.jpg) dans votre article, à l'endroit où vous souhaitez faire apparaitre l'image.

Gérer le contenu liés aux thèmes (photos de fond, avatars, etc.)​

Dans ces cas là, la gestion des images locales peut être compliquées à gérer si on souhaite que le fonctionnement soit identique que l'on utilise le moteur hugo en local ou dans la version Gitlab Pages.

C'est pour cette raison que je propose de le gérer de la manière suivante :

Créer un répertoire appelé "static" à la racine de votre site. Placez-y directement les images que vous souhaitez utiliser, sans les mettre dans un sous-répertoire. Elles seront alors utilisables dans votre fichier de paramétrage config.toml en donnant simplement leur nom.

Mais vous devez faire attention, car le quickstart de la doc officielle n'est pas compatible avec un déploiement sur Gitlab Pages.

Comment démarrer rapidement avec hugo​

Voici comment mieux commencer avec Hugo selon moi :

étape 1 - Sélection du thème​

Tout d'abord, choisissez attentivement le thème que vous souhaitez utiliser. C'est important car la façon dont vous allez configurer votre site Web peut être (très) spécifique à votre thème.

Pour choisir judicieusement, il suffit d'aller sur themes.gohugo.io et de regarder la démo de ceux qui vous intéressent. Toutes les démos intègrent la restitution de la syntaxe markdown, ce qui permet de s'assurer que le thème répond à vos souhaits!

étape 2 - Nom du site Web​

Deuxièmement, choisissez le nom du site Web. Ce doit être le nom du dossier. lorsque vous déploierez votre site Web sur les pages gitlab, vous auriez le site Web suivant URL: http://username.gitlab.io/foldername/

Si vous créez un blog, "blog" serait un bon nom. Si vous êtes sur le site Web pour proposer un produit, "productName" serait pertinent.

Étape 3 - Création de site Web​

C'est la partie la plus simple du tutoriel. Il suffit simplement de saisir la commande suivante:

hugo new site <nom_dossier>

Maintenant, vous avez un nouveau dossier appelé nom_dossier avec des éléments. Avant de faire quoi que ce soit, suivez l'étape suivante. N'ENTREZ PAS DANS LE NOUVEAU DOSSIER

Étape 4 - Téléchargement du thème​

Allez sur le repository du thème choisi et NE CLONEZ PAS le référentiel git. Récupérez le fichier zip et décompressez-le sur nom_dossier/themes/nom_thème. (Oui, cette fois, vous entrez dans le nom_dossier)

Attention, le contenu du thème doit être sur nom_thème, pas sur nom_thème/hugo-theme-name-master.

étape 5 - Utilisez exampleSite comme modèle​

Copiez le nom_thème/exampleSite/config.toml directement sur votre nom de dossier, en remplaçant celui créé en standard.

Sur le fichier config.toml, modifiez la ligne de sélection de thème en

theme = "<nom_thème>"

Puisque vous souhaitez utiliser hugo avec les pages gitlab, vous devez également modifier le baseURL sur config.toml:

baseurl = "https://<username>.gitlab.io/<foldername>"

Déploiement de pages Gitlab​

Attention​

NE RIEN FAIRE DANS GIT! Vous allez créer un projet gitlab que vous initierez avec votre foldername

étape 6 - Créer un projet gitlab​

Sur gitlab, créez un nouveau projet, du même nom que votre dossier. Ne l'initialisez pas avec un fichier readme ou autre chose.

étape 7 - Créez votre fichier CI​

Allez sur le nom de votre dossier, et créez un fichier appelé .gitlab-ci.yml

Modifiez le fichier avec le code suivant:

image: monachus/hugo

variables:
  GIT_SUBMODULE_STRATEGY: recursive

pages:
  script:
  - hugo
  artifacts:
    paths:
    - public
  only:
  - master

étape 8 - Poussez votre site Web​

Tout d'abord, lancez le repo:

git init

Ensuite, ajoutez le répertoire /public au fichier .gitignore

echo "/public" >> .gitignore

Enfin, validez et pushez le code sur la branche principale

git add .
git commit -m "Initial commit"
git remote add origin https://gitlab.com/YourUsername/your-hugo-site.git
git push -u origin master

étape 9 - See & Wait​

Allez dans l'onglet "CI / CD pipeline" de votre repository gitlab

Surveillez l'étape de build et attendez qu'elle soit passée. Vous y êtes ! Votre site Web est publié sur username.gitlab.io/foldername

Merci de votre visite sur notre blog généraliste sur les outils d'IT. On y parle Vagrant, Ansible, Docker, Git, CI/CD, etc. Il s'agit simplement d'un support pour formaliser les activités de veilles de deux bad it boys !

A propos du site:​

Voici quelques information techniques au sujet de ce site

La Stack​

Pour mettre à dispo nos articles, nous utilisons la JAMstack: Javascript, Apis, Mark-up languages.

Plus précisemment, notre stack se compose des outils suivants:

Nous rédigeons nos articles en Markdown, en stockant et partageant nos images sur Cloudinary. Le blog est ensuite construit avec hugo, puis il est testé et déployé sur Netlify grâce à Gitlab CI/CD.

Ce qui donne le workflow suivant:

{{}}