Dagger, mesin pipeline ringan, dapat dieksekusi dari dev ke CI/CD

Dalam ekosistem platform CI/CD (GitHub Actions, GitLab CI, Jenkins, CircleCI, dll.), tidak ada standar. Memang benar bahwa setiap platform menerapkan sintaks definisi salurannya sendiri: YAML untuk GitHub, Groovy untuk Jenkins, dll. Pengelolaan komponen yang dapat digunakan kembali juga berbeda: GitHub menggunakan tindakan, Jenkins menggunakan perpustakaan bersama, dll.

Selain itu, terlepas dari beberapa inisiatif seperti tindakan, menjalankan pipeline CI/CD di stasiun kerja pengembang masih merupakan hal yang rumit. Pengembang cenderung mengatasi keterbatasan ini dengan mengimplementasikan bagian dari pipeline CI/CD dengan alat standar (makefile, skrip shell, dll.).

Seperti yang akan kita lihat di artikel ini, Dagger mengatasi masalah ini dengan memungkinkan Anda mendefinisikan pipeline (disebut “fungsi” dalam kosakata Dagger) menggunakan bahasa pemrograman standar (Python, Go, TypeScript, dll.). Pipeline ini berjalan pada platform CI/CD yang sudah ada dan secara lokal pada stasiun kerja pengembangan.

Cara kerja Belati

Belati bertumpu pada a mesin yang mengatur pelaksanaan fungsi. Mesin ini, dilengkapi dengan berbagai kemampuan seputar Docker, memungkinkan, antara lain, untuk:

• Membangun image Docker
• Publikasikan gambar Docker
• Mulai kontainer

Sintaks Dagger terinspirasi oleh skrip shell, dengan prinsip merangkai fungsi melalui simbol |.

Seperti yang ditunjukkan pada gambar di bawah, arsitektur Dagger juga didasarkan pada a Grafik APIQL. Yang memungkinkan Anda berinteraksi dengan mesin Dagger melalui klien yang berbeda:

• Dari SDK dalam berbagai bahasa (Go, Python, Java, dll.)
• Dan CLI belati untuk eksekusi baris perintah

Fungsi Helloworld

Untuk memahami konsep dasar Dagger, mari kita mulai dengan contoh sederhana yang mengilustrasikan sintaksis dan prinsip rangkaian fungsi.

Contoh fungsi Dagger yang memulai gambar alpine dan menjalankan echo helloworld:

container | from alpine:latest | # démarre l'image alpine
with-exec echo "helloworld" | # exécute la commande echo dans le conteneur
stdout # affiche le résultat

Membangun image Docker melalui Dagger CLI

Kami sekarang akan membuat image Docker dari aplikasi Java SpringBoot dengan dua cara berbeda.

Membangun citra Java

Membuat image Docker dari Dagger CLI:

container | from maven:latest | # démarre l'image maven:latest
with-directory /src . | # monte le répertoire courant dans le conteneur à l'emplacement /src
with-workdir /src | # définit le répertoire de travail à /src
with-exec mvn clean install | # exécute la commande mvn clean install
with-entrypoint mvn spring-boot:run | # définit le point d'entrée du conteneur
publish ttl.sh/dagger-wescale-app:1h # publie l'image sur ttl.sh

Konstruksi melalui Dockerfile

Alternatif menggunakan Dagger CLI dan Dockerfile yang sudah ada:

directory | # initie un contexte de build
with-file Dockerfile Dockerfile | # ajoute le fichier Dockerfile
with-file pom.xml pom.xml | # ajoute le fichier pom.xml
with-directory src src | # ajoute le répertoire src
docker-build | # construit l'image docker
publish ttl.sh/dagger-wescale-app:1h # publie l'image sur ttl.sh

# équivalent dagger : from maven:latest
FROM maven:latest
# équivalent dagger : with-workdir /src
WORKDIR /src
# équivalent dagger : with-directory /src .
COPY . /src
# équivalent dagger : with-exec mvn clean install
RUN mvn clean install
# équivalent dagger : with-entrypoint mvn spring-boot:run
CMD ["mvn", "spring-boot:run"]

Menerapkan fungsi Helloworld

Untuk menggunakan kembali pipeline dan membuat versinya dengan mudah, kita akan membuat fungsi Dagger sendiri dengan Python.

Menginisialisasi proyek Dagger Python:

dagger init # initialise le projet Dagger
dagger develop --sdk=python # génère du code d'une fonction Dagger en python

Kode sumber dari fungsi yang dihasilkan container_echo :

• memulai wadah dari gambar alpine:latest
• jalankan perintah echo dengan argumen string_arg

import dagger
from dagger import dag, function, object_type
@object_type
class DaggerTasks:
   @function
   def container_echo(self, string_arg: str) -> dagger.Container:
       """Returns a container that echoes whatever string argument is provided"""
       return dag.container().from_("alpine:latest").with_exec(["echo", string_arg])

Pemanggilan fungsi

Kami sekarang akan menjalankan fungsinya container_echo dalam dua cara yang berbeda. Dalam kasus pertama, kode modul Dagger bersifat lokal. Dalam kasus kedua, kode modul dihosting di GitHub.

Memanggil fungsi dengan kode lokal

Eksekusi lokal container_echo :

dagger -m ../dagger-tasks call container-echo --string_arg helloworld stdout

Memanggil fungsi dengan kode di Github

Berjalan melalui modul GitHub:

dagger -m github.com/elkouhen/dagger-tasks call container-echo --string_arg helloworld stdout

Menerapkan fungsi “membangun Maven”.

Sekarang mari kita buat sebuah fungsi build_mvn yang membangun image Docker dari aplikasi Java SpringBoot dan menerbitkan image Docker ke ttl.sh (repositori image sementara).

Kode sumber fungsi build_mvn :

   @function
   async def build_mvn(self, source: dagger.Directory, image_name: str) -> str:
       """
       Builds a Maven project from the provided source directory and publishes the image to the specified image name.
       :param source: The source directory containing the Maven project.
       :param image_name: The name of the image to publish.
       :return: The reference of the published image.
       """
       return await (dag.container()
                     .from_("maven:latest")  # démarre avec Maven
                     .with_directory("/src", source)  # monte le code source
                     .with_workdir("/src")  # définit le répertoire de travail
                     .with_exec(["mvn", "clean", "install", "-DskipTests"])  # compile le projet
                     .with_entrypoint(["mvn", "spring-boot:run"])  # définit le point d'entrée
                     .publish(image_name))  # publie l'image

Pemanggilan fungsi secara lokal

Berikut cara menjalankan fungsinya build_mvn secara lokal dengan Dagger CLI:

dagger -m ../dagger-tasks call build-mvn --source=. --image-name="ttl.sh/dagger-wescale-app:1h"

Integrasi berkelanjutan GitHub dengan Dagger

Salah satu keunggulan utama Dagger adalah kemampuannya untuk berintegrasi ke dalam alur kerja CI/CD yang ada. Mari kita lihat cara menggunakan fungsi Dagger di GitHub Actions.

Mengintegrasikan Dagger ke dalam alur kerja GitHub cukup sederhana melalui belati-untuk-github.

Contoh alur kerja Tindakan GitHub menggunakan Dagger:

on: [push]  # déclenché à chaque push
jobs:
   build:
       name: build
       runs-on: ubuntu-latest
       steps:
       - name: Checkout
         uses: actions/checkout@v4  # récupère le code
       - name: Build Jar
         uses: dagger/[email protected]  # utilise l'action Dagger
         with:
           version: "latest"
           args: build-mvn --source=. --image-name="ttl.sh/dagger-wescale-app:1h"
           module: github.com/elkouhen/dagger-tasks  # module Dagger

Kesimpulan

Setelah menjelajahi Dagger melalui contoh-contoh praktis ini, mari kita lihat apa yang dibawa alat ini ke ekosistem CI/CD.

Dagger mewakili cara baru untuk merancang dan mengeksekusi pipeline CI/CD. Memang benar, alat ini menawarkan kemungkinan untuk mendefinisikan jaringan pipa portabel, yang tidak bergantung pada platform tertentu, namun tetap dapat diintegrasikan dengan solusi yang ada.

Dagger bukanlah platform CI/CD yang lengkap, namun mesin eksekusi pipeline.

Alat ini sangat menarik untuk:

• Organisasi yang ingin mengurangi ketergantungan mereka pada platform CI/CD tertentu;
• Tim ingin meningkatkan kualitas aplikasi mereka dengan menguji pipeline mereka secara lokal, tanpa harus menduplikasi logika CI/CD.

Masukan

Artikel ini adalah hasil eksperimen yang dilakukan selama hackathon satu hari di WeScale, dengan dua pasang saya hari itu Vincent Ringuedé dan Rémi Calizzano.

Dagger adalah alat yang menyenangkan dan menarik untuk digunakan, namun tetap sedikit muda: Saya harus mengelola beberapa bug (dengan cepat diperbaiki oleh tim pengembangan) serta evolusi API.

Titik lemah utama Dagger tetap menjadi gudang modul komunitas: belati. Ada banyak modul yang sering kali berlebihan. Yang lebih mengkhawatirkan lagi, beberapa modul yang diuji ternyata tidak berfungsi, yang saat ini membatasi keandalan repositori ini.

Untuk proyek apa pun yang memerlukan CI/CD kompleks, Dagger kini menjadi opsi untuk dipertimbangkan.