Dagger et Authentification à un registre OCI

Dans la partie précédente, nous avons vu comment utiliser Dagger pour build notre Dockerfile. A présent, nous allons voir comment push ce build sur un registre privé.

Pour ce tutoriel, je vais utiliser le registre de chez Scaleway, mais vous pouvez utiliser n’importe quel registre OCI !

Authentification

Bien sur, pour pouvoir pousser sur un registre privé, il faut avoir un token d’authentification. Je vais donc aller sur l’interface de Scaleway et créer un token associé à mon compte.

Une fois le token créé, je vais cloner le projet de l’article précédent. https://github.com/Killian-Aidalinfo/node-api-demo-dockerfile

Dans notre index.ts de dagger, nous avons cette base :

import { dag, Container, Directory, object, func, Secret } from "@dagger.io/dagger"

@object()
export class NodeApiDemo {

  @func()
  build(source: Directory): Container {
    const devDirectory = this.dev(source)
    return dag
      .container()
      .withDirectory("/app", devDirectory)
      .build(devDirectory,{dockerfile: "Dockerfile"})
  }


  @func()
  dev(source: Directory): Directory {
    const nodeCache = dag.cacheVolume("node")
    const npmInstall = dag
        .container()
        // start from a base Node.js container
        .from("node:lts")
        // add the source code at /src
        .withDirectory("/app", source)
        // mount the cache volume at /root/.npm
        .withMountedCache("/root/.npm", nodeCache)
        // change the working directory to /src
        .withWorkdir("/app")
        // run npm install to install dependencies
        .withExec(["npm", "install"])
    // Return directory
    return npmInstall.directory("/app")
  }

}

Vous l’avez vu venir, nous allons rajouter une étape publish afin de pousser notre image sur le registre privé. Et comment Dagger l’a déjà prévu, nous allons pouvoir le faire facilement en quelques lignes de code.

  @func()
  async publish(source: Directory, secretScaleway: Secret): Promise<string> {
    return await this.build(source)
      .withRegistryAuth("rg.fr-par.scw.cloud/namespace-great-wilson","nologin",secretScaleway)
      .publish("rg.fr-par.scw.cloud/namespace-great-wilson/node-api-demo:latest")
  }

Nous allons avoir en paramètre le source de notre projet pour le build et le secret Scaleway pour l’authentification.

Nous partons de notre build avec this.build(source) et nous ajoutons la fonction withRegistryAuth avec l’url de notre registre, le nom d’utilisateur et le token. Ensuite, comme vous l’avez déjà vu dans l’introduction à dagger, nous utilisons la fonction publish pour pousser notre image sur le registre en donnant le nom de notre image.

On test ?

Test

On va donc lancer notre fonction publish avec notre token Scaleway.

dagger call publish --source=. --secretScaleway=env:SCALEWAY_TOKEN

Et voilà, notre image est bien poussée sur le registre !

On maintenant la cloner sur notre hôte pour la tester, ici on pourrais imaginer un pull sur la production ! Avec toutes ces étapes réalisées avec Dagger nous sommes production ready !

docker pull rg.fr-par.scw.cloud/namespace-great-wilson/node-api-demo
docker run -p 9002:8080 rg.fr-par.scw.cloud/namespace-great-wilson/node-api-demo

Conclusion

Comme vous l’avez vu, avec Dagger, en quelques lignes de code nous pouvons pousser notre image sur un registre privé. Et avec un sacré avantage, tester en local avant de push sur Github ou Gitlab en tant que action !

Prévention

Étant donnée que nous utilisons le cache docker, il faut faire attention car ce secret peut se retrouver dans le cache. Voici un article intéressant à ce sujet : https://openmeter.io/blog/secure-registry-access-with-dagger#taking-it-a-step-further

Github

Lien du projet : node-api-demo-registry