Vous pouvez ouvrir une autre console et vous placer dans le dossier « terraform ». Nous allons vérifier le build et l’install de ce provider.

terraform init
terraform plan

Nous avons donc notre custom provider configuré et fonctionnel, même si pour le moment il ne fait pas grand chose !

Nous allons maintenant entrer dans le vif du sujet, mais allons-y étape par étape. Nous commençons par développer une première « data » Terraform qui correspondra à l’ensemble des cours renvoyés par l’API. Pour rappel Terraform a deux types d’objets qu’on manipule à travers les providers:

• les ressources, qui correspondent aux objets que vous créez. Par exemple, une adresse IP ou un repository GitHub.
• les datas, qui correspondent à des informations renvoyées par un provider. Par exemple, une data qui contiendra la liste des membres d’une équipe GitHub.

Commençons par lancer notre docker-compose.

docker-compose up -d

Ces routes sont disponibles dans l'api,
GET   http://localhost:4000/cours, renvoie une liste de cours
POST http://localhost:4000/cours, crée un cour avec ce body 
{
    "name": "Petit intervention",
    "time": 60,
    "summary": "intervention sur sujet tech"
}
PUT http://localhost:4000/cours/651fc2f3970d6264792bf49e, avec le même body que pour le POST
DELETE http://localhost:4000/cours/65201115d9a28e309a48d610, qui supprime le cours.

Vous pouvez maintenant copier coller les fichiers du dossier « docs/providers/step1 », dans le dossier « custom-provider/resources/terraform-provider-courses/courses »

Le fichier, « data_source_courses.go », contient la définition de notre data source pour les cours.
Il existe deux méthodes importantes. « dataSourceCourses », qui est le point d’entré pour terraform pour comprendre comment interagir avec cette « data ». Dans cette méthode vous avez deux options, « ReadContext », qui prend en valeur la fonction qui sera exécutée pour renvoyer la valeur de cette data, et « Schema », qui sert à définir le schéma de la donnée renvoyée par le provider.
Dans ce même fichier, vous avez la méthode « dataSourceCoursesRead », qui sera appelée pour récupérer la data. Dans celle-ci vous remarquerez que ce n’est qu’un bout de code qui fait un appel à notre API (cf ligne 57). Autre ligne intéressante, la ligne 79. Sur celle-ci, nous voyons que nous associons un id à notre data, primordial à Terraform ! Je vous invite maintenant à builder la version 0.2 de votre provider (n’oubliez pas de monter la version dans le Makefile !)
Vous trouverez également les fichiers Terraform pour tester cette nouvelle version. Utilisez les fichiers dans le dossier docs, example1.tf. Vous pouvez créer un ou plusieurs cours via l’API. Utilisez les commandes suivantes pour installer la nouvelle version du module et lancer le plan Terraform. Vous pouvez l’apply si vous le souhaitez. (/!\ pour la suite, si vous appliquez des objects entre différentes versions du provider ou si vous relancez le docker compose, n’oubliez pas de clean vos states Terraform, pour repartir de zéro)

terraform init --upgrade
terraform plan

Maintenant nous nous attaquons à la création de ressources! Nous commençons par la création d’un cours!
Comme pour l’étape précédente, vous pouvez prendre les fichiers dans les ressources step2 et example2!

Comme vous pouvez le constater le main.tf ne va pas changer, seul le provider.tf va subir une modification. En plus de la partie data, nous rajoutons maintenant notre ressource « ekite_cour », qui va nous permettre de créer, récupérer, mettre à jour ou supprimer un cours dans notre API.
C’est la méthode dataSourceCour(), qui va contenir toutes les méthodes nécessaires aux actions d’une ressource Terraform, celle-ci implémentant les méthodes fournies par Hashicorp.
On peut voir que la méthode DataSourceCour(), renvoie un objet *schema.Resource qui prend en paramètre des méthodes de « Contexte », qui implémentent le code qui va être lié aux actions sur la ressource. C’est pour cela qu’on en retrouve une pour Create Read Update Delete.
Dans ces méthodes, je vais seulement implémenter des calls à mon API, et le code nécessaire à Terraform pour garantir la consistance des ressources maintenues par ce provider. Ce code n’étant que le set d’un id à la ressource Terrafom, qui lui permet de l’identifier dans son backend Terraform.
On peut voir que j’utilise la variable « d » qui correspond à la ressource qu’on est en train de manipuler. Je peux récupérer les différentes valeurs poussées dans la définition de la ressource.

package courses

import (
    "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

// Provider -
func Provider() *schema.Provider {
    return &schema.Provider{
        ResourcesMap: map[string]*schema.Resource{
            "ekite_cour": dataSourceCour(),
        },
        DataSourcesMap: map[string]*schema.Resource{
            "ekite_courses": dataSourceCourses(),
        },
    }
}

package courses

import (
    "bytes"
    "context"
    "encoding/json"
    "log"
    "net/http"

    "github.com/hashicorp/terraform-plugin-sdk/v2/diag"

    "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

type Cour struct {
    Id      string `json:"_id"`
    Name    string `json:"name"`
    Time    int    `json:"time"`
    Summary string `json:"summary"`
}

func dataSourceCour() *schema.Resource {
    return &schema.Resource{
        CreateContext: resourceCourCreate,
        ReadContext:   resourceCourRead,
        UpdateContext: resourceCourUpdate,
        DeleteContext: resourceCourDelete,

        Schema: map[string]*schema.Schema{
            "_id": &schema.Schema{
                Type:     schema.TypeString,
                Optional: true,
            },
            "name": &schema.Schema{
                Type:     schema.TypeString,
                Required: true,
            },
            "time": &schema.Schema{
                Type:     schema.TypeInt,
                Required: true,
            },
            "summary": &schema.Schema{
                Type:     schema.TypeString,
                Required: true,
            },
        },
    }
}

func resourceCourCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {

    var diags diag.Diagnostics

    name := d.Get("name").(string)
    time := d.Get("time").(int)
    summary := d.Get("summary").(string)

    data := map[string]interface{}{
        "name":    name,
        "time":    time,
        "summary": summary,
    }

    jsonData, err := json.Marshal(data)

    resp, err := http.Post("http://localhost:4000/cours", "application/json", bytes.NewBuffer(jsonData))

    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    cour := &Cour{}
    err = json.NewDecoder(resp.Body).Decode(&cour)
    if err != nil {
        return diag.FromErr(err)
    }
    // THIS IS MANDATORY FOR TERRAFORM TO BE ABLE TO GARANT CONSISTENCY OF YOUR RESOURCES
    d.SetId(cour.Id)
    return diags
}

func resourceCourRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {

    return nil
}

func resourceCourUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {

    return nil
}

func resourceCourDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {

    return nil
}

Vu que dans cette étape nous n’implémentons que la méthode de création, si vous vous amusez à éditer ou supprimer la ressource, rien ne se passera, même pas une erreur ! Par contre, vos states Terraform seront complètement corrompus. Si c’est le cas n’hésitez pas à tout supprimer et réinitialiser votre workspace Terraform. Pour créer la ressource, comme d’habitude, montez la version, réinstallez votre provider local, votre petit « terraform init –upgrade » et prenez le contenu du fichier exemple2.tf. Vous venez de mettre en place la création d’une ressource par Terraform.

terraform {
  required_providers {
    courses = {
      version = "0.0.2"
      source  = "hashicorp.com/ekite/courses"
    }
  }
}

resource "ekite_cour" "mon_cour" {
  provider = courses
  name = "Cour créé depuis terraform"
  time = 60
  summary = "Un simple exemple"
}

Maintenant vous pouvez soit aller directement à l’étape 4, qui finit par implémenter la suppression de ressource, soit passer par la 3 qui commence par implémenter les méthodes de lecture et de mise à jour. Dans mon cas je vais aller à l’étape 4 et expliquer le code final qui comprend les deux.
Donc maintenant je voudrais pouvoir éditer mes ressources Terraform, et pour ce faire je pensais qu’implémenter la méthode « resourceCourUpdate » suffirait. Mais non, cela dépend de la méthode « read », puisque Terraform, avant de mettre à jour votre ressource, va aller la lire dans votre système d’information.
La méthode de lecture a été la plus simple a implémenter, dans le sens où il n’y pas de spécificité propre à Terraform, comme on la vu précédemment avec le set de l’id dans la méthode de create. En revanche, dans la méthode d’update, nous retrouvons une instruction spécifique à Terraform, « d.Set(« last_updated », time.Now().Format(time.RFC850)) ». Celle-ci est indispensable à Terraform. Encore une fois pour garantir la persistance et la cohérence de vos ressources Terraform. Du côté du delete, on retrouve la même idée que pour le create, mais ici nous allons juste supprimer l’id de notre ressource.

package courses

import (
    "bytes"
    "context"
    "encoding/json"
    "log"
    "net/http"
    "time"

    "github.com/hashicorp/terraform-plugin-sdk/v2/diag"

    "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

type Cour struct {
    Id      string `json:"_id"`
    Name    string `json:"name"`
    Time    int    `json:"time"`
    Summary string `json:"summary"`
}

func dataSourceCour() *schema.Resource {
    return &schema.Resource{
        CreateContext: resourceCourCreate,
        ReadContext:   resourceCourRead,
        UpdateContext: resourceCourUpdate,
        DeleteContext: resourceCourDelete,

        Schema: map[string]*schema.Schema{
            "_id": &schema.Schema{
                Type:     schema.TypeString,
                Optional: true,
            },
            "name": &schema.Schema{
                Type:     schema.TypeString,
                Required: true,
            },
            "time": &schema.Schema{
                Type:     schema.TypeInt,
                Required: true,
            },
            "summary": &schema.Schema{
                Type:     schema.TypeString,
                Required: true,
            },
            "last_updated": &schema.Schema{
                Type:     schema.TypeString,
                Optional: true,
                Computed: true,
            },
        },
    }
}

func resourceCourCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {

    var diags diag.Diagnostics

    name := d.Get("name").(string)
    time := d.Get("time").(int)
    summary := d.Get("summary").(string)

    data := map[string]interface{}{
        "name":    name,
        "time":    time,
        "summary": summary,
    }

    jsonData, err := json.Marshal(data)

    resp, err := http.Post("http://localhost:4000/cours", "application/json", bytes.NewBuffer(jsonData))

    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    cour := &Cour{}
    err = json.NewDecoder(resp.Body).Decode(&cour)
    if err != nil {
        return diag.FromErr(err)
    }
    // THIS IS MANDATORY FOR TERRAFORM TO BE ABLE TO GARANT CONSISTENCY OF YOUR RESOURCES
    d.SetId(cour.Id)
    return diags
}

func resourceCourRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
    var diags diag.Diagnostics
    client := &http.Client{Timeout: 10 * time.Second}

    url := "http://localhost:4000/cours/" + d.Id()

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return diag.FromErr(err)
    }

    r, err := client.Do(req)
    if err != nil {
        return diag.FromErr(err)
    }
    defer r.Body.Close()
    cour := &Cour{}
    err = json.NewDecoder(r.Body).Decode(&cour)
    if err != nil {
        return diag.FromErr(err)
    }
    d.Set("name", cour.Name)
    d.Set("time", cour.Time)
    d.Set("summary", cour.Summary)

    return diags
}

func resourceCourUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
    client := &http.Client{Timeout: 10 * time.Second}
    name := d.Get("name").(string)
    timeobj := d.Get("time").(int)
    summary := d.Get("summary").(string)

    data := map[string]interface{}{
        "name":    name,
        "time":    timeobj,
        "summary": summary,
    }

    jsonData, err := json.Marshal(data)

    url := "http://localhost:4000/cours/" + d.Id()

    req, err := http.NewRequest(http.MethodPut, url, bytes.NewBuffer(jsonData))
    if err != nil {
        log.Fatal(err)
    }
    req.Header.Set("Content-Type", "application/json; charset=utf-8")
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    // THIS IS MANDATORY FOR TERRAFORM TO BE ABLE TO GARANT CONSISTENCY OF YOUR RESOURCES
    d.Set("last_updated", time.Now().Format(time.RFC850))
    return resourceCourRead(ctx, d, m)
}

func resourceCourDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
    var diags diag.Diagnostics
    client := &http.Client{}
    url := "http://localhost:4000/cours/" + d.Id()
    req, err := http.NewRequest("DELETE", url, nil)
    if err != nil {
        panic(err)
    }
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    // THIS IS MANDATORY FOR TERRAFORM TO BE ABLE TO GARANT CONSISTENCY OF YOUR RESOURCES
    d.SetId("")
    return diags
}

Une fois que vous avez mis à jour votre code, même chose, on rebuild on réinstalle et on réinitialise et vous pouvez vous amuser avec votre provider.

Si vous voulez un résumé vous pouvez trouver le déroulé de ce pas à pas ici: https://www.youtube.com/watch?v=hVoPL61x5dI

Conseils et conclusion