ഡാഗറിനൊപ്പം യഥാർത്ഥ കോഡിലുള്ള പൈപ്പ്ലൈനുകൾ

ഇതാ ഒരു ലൂപ്പ് ഓരോ ഡെവ് ഒപ്സ് എഞ്ചിനീയർ അറിയുന്നു. പൈപ്പ് ലൈന് YAML മാറ്റി വയ്ക്കുക. പ്രതിജ്ഞാബദ്ധം. തള്ളി. ഐ. സി. ക്ക് വേണ്ടി കാത്തിരിക്കൂ. ഒരു ടൈപ്പ് പിശകില് അത് പരാജയപ്പെടുന്നു. ശരിയാക്കുക. "ഫിക്സ് സി" നടത്തുക. തള്ളി. കാത്തിരിക്കൂ. പരാജയം. "വീണ്ടും ശരിയാക്കുക". 20 കമീറ്റ്സ് കഴിഞ്ഞ്, അത് പ്രവർത്തിക്കുന്നു, ഗിറ്റ് ചരിത്രം ഒരു സഹായത്തിനായി നിലവിളിക്കുന്നതായി തോന്നുന്നു.

പ്രധാന പ്രശ്നം മിക്ക പൈപ്പ്ലൈനുകളും സിഐ സിസ്റ്റത്തിനകത്ത് മാത്രമേ പ്രവർത്തിക്കാവൂ എന്നതാണ്. നിങ്ങളുടെ ലാപ്ടോപ്പിൽ പ്രവർത്തിപ്പിക്കാനോ ശരിയായി ഡീബഗ് ചെയ്യാനോ YAML പകർത്താതെ ലോജിക് വീണ്ടും ഉപയോഗിക്കാനോ കഴിയില്ല. ഡാഗര് അത് പരിഹരിക്കാൻ ശ്രമിക്കുന്നു.

YAML പ്രശ്നം

സിഐ യാംല് ഒരു പ്രോഗ്രാമിങ് ഭാഷയായി വളര് ന്നു. ആരും അത് പോലെ രൂപകല് പിച്ചിട്ടില്ല. അവസ്ഥ, ലൂപ്പുകൾ, വേരിയബിളുകൾ, ടെംപ്ലേറ്റുകൾ, സ്ട്രിങ്ങുകൾക്കുള്ളിലെ പദപ്രയോഗങ്ങൾ. പക്ഷേ ഡീബഗ്ഗർ, ടെസ്റ്റുകൾ, ടൈപ്പ് ചെക്ക്, കോഡ് പങ്കിടാനുള്ള നല്ല മാർഗങ്ങൾ എന്നിവ ഇല്ലാതെ.

ഓരോ ഐ. ഐ. സിസ്റ്റത്തിനും അതിന്റേതായ ഭാഷയുണ്ട്. ഗിറ്റ്ഹബ് ആക്ഷനുകൾക്കായി എഴുതിയ ഒരു പൈപ്പ്ലൈൻ ഗിറ്റ്ലാബിലോ ജെൻകിൻസിലോ നിങ്ങളുടെ ലാപ്ടോപ്പിലോ പ്രവർത്തിക്കില്ല.

ഡാഗർ ചെയ്യുന്നതെന്താണ്

ഡോക്കർ ടീമിലെ ചിലര് സൃഷ്ടിച്ച കത്തി, പൈപ്പ്ലൈനുകള് എഴുതാന് നിങ്ങളെ അനുവദിക്കുന്നു ഒരു യഥാർത്ഥ പ്രോഗ്രാമിങ് ഭാഷയിലെ കോഡ്: ഗോ, പൈത്തൺ, ടൈപ്പ്സ്ക്രിപ്റ്റ് തുടങ്ങിയവ. ഓരോ ഘട്ടവും ഒരു കണ്ടെയ്നറിൽ പ്രവർത്തിക്കുന്നു, ബിൽഡ്കിറ്റ് അടിസ്ഥാനമാക്കിയുള്ള എഞ്ചിൻ ഉപയോഗിച്ച്. നിങ്ങളുടെ ലാപ്ടോപ്പിലും മറ്റേതൊരു സിസ്റ്റത്തിലും ഒരേ പാപ്പ്ലൈൻ പ്രവർത്തിക്കുന്നു.

നിങ്ങളുടെ ഐ. സി. ക്രമീകരണം "ഡാഗർ ഇൻസ്റ്റാൾ ചെയ്യുക, ഈ ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുക" എന്നതിലേക്ക് ചുരുങ്ങുന്നു.

എന്റെ ആദ്യത്തെ ഡാഗര് പൈപ്പ്ലൈന്

Go-യിൽ ഒരു ചെറിയ ഉദാഹരണം: ഒരു ആപ്ലിക്കേഷൻ നിർമ്മിക്കുകയും പരിശോധിക്കുകയും ചെയ്യുക, പിന്നെ ഒരു കണ്ടെയ്നർ ഇമേജ് നിർമ്മിക്കുക.

package main

import (
    "context"
    "dagger/shop/internal/dagger"
)

type Shop struct{}

// Run the tests
func (m *Shop) Test(ctx context.Context, source *dagger.Directory) (string, error) {
    return dag.Container().
        From("golang:1.25").
        WithMountedCache("/go/pkg/mod", dag.CacheVolume("go-mod")).
        WithDirectory("/src", source).
        WithWorkdir("/src").
        WithExec([]string{"go", "test", "./..."}).
        Stdout(ctx)
}

// Build the production image
func (m *Shop) Build(source *dagger.Directory) *dagger.Container {
    binary := dag.Container().
        From("golang:1.25").
        WithDirectory("/src", source).
        WithWorkdir("/src").
        WithEnvVariable("CGO_ENABLED", "0").
        WithExec([]string{"go", "build", "-o", "/app", "./cmd/server"}).
        File("/app")

    return dag.Container().
        From("gcr.io/distroless/static-debian12:nonroot").
        WithFile("/app", binary).
        WithEntrypoint([]string{"/app"})
}

പിന്നെ, നിങ്ങളുടെ ടെർമിനലിൽ നിന്നും:

dagger call test --source=.
dagger call build --source=. publish --address=ghcr.io/my-org/shop-api:dev

ഇത് സാധാരണ ഗോ കോഡാണ്. നിങ്ങള് ക്ക് ഓട്ടോമാറ്റിക് പൂര് ത്തിയാക്കല് , തരം , ഫംഗ്ഷനുകൾ , ലൂപ്പുകൾ , പിശക് കൈകാര്യം ചെയ്യല് , നിങ്ങള് ക്ക് നിങ്ങളുടെ പൈപ്പ്ലൈന് ലോജിക് മറ്റേതൊരു കോഡും പോലെ പരീക്ഷിക്കാം.

ഏറ്റവും നല്ല ഐ. ഐ. പൈപ്പ്ലൈൻ മറ്റാരെങ്കിലും കാണുന്നതിന് മുമ്പ് നിങ്ങളുടെ സ്വന്തം മെഷീനിൽ പ്രവർത്തിപ്പിക്കാനും ഡീബഗ് ചെയ്യാനും ശരിയാക്കാനും കഴിയുന്നതാണ്.

ഒരേ പൈപ്പ്ലൈൻ പ്രാദേശികമായും CI ലും

ഗിറ്റ്ഹബ് ആക്ഷനുകളിൽ, വർക്ക്ഫ്ലോ വളരെ ചെറുതായിത്തീരുന്നു:

- uses: dagger/dagger-for-github@<sha>
  with:
    verb: call
    args: test --source=.

നാളെ ഗിറ്റ്ലാബിലേക്കോ ജെൻകിൻസിലേക്കോ പോകൂ, ആ കുറച്ച് വരികൾ മാത്രമേ മാറുകയുള്ളൂ. പൈപ്പ് ലൈനിന് റെ അവസ്ഥയും അതേപടി തന്നെ.

കാഷെ ഇൻബിൽറ്റ് ചെയ്തിരിക്കുന്നുഃ ഓരോ ഘട്ടവും അതിന്റെ ഇൻപുട്ടുകൾ കാഷെ ചെയ്യുന്നു, അതിനാൽ മാറ്റമില്ലാത്ത ഘട്ടങ്ങൾ പ്രാദേശികമായും CI- ലും ഒഴിവാക്കപ്പെടുന്നു (CI റണ്ണർ കാഷെ സൂക്ഷിക്കുന്നു അല്ലെങ്കിൽ ഡാഗറിന്റെ ക്ലൌഡ് കാഷെ ഉപയോഗിക്കുന്നുവെങ്കിൽ).

പുനരുപയോഗം ചെയ്യാവുന്ന മൊഡ്യൂളുകൾ

ഡാഗറിന് ഒരു മോഡുലര് സംവിധാനമുണ്ട്. മറ്റുള്ളവർ എഴുതിയ മൊഡ്യൂളുകൾ (ഉദാഹരണത്തിന്, ലിൻറ്റിംഗ്, സ്കാനിംഗ് അല്ലെങ്കിൽ വിന്യസിക്കൽ) നിങ്ങൾക്ക് വിളിക്കാം അല്ലെങ്കിൽ നിങ്ങളുടെ ഓർഗനൈസേഷനിൽ നിങ്ങളുടെ സ്വന്തം പങ്കിടാം. ഇത് ഒരു പൈപ്പ്ലൈൻ ലോജിക് പങ്കുവയ്ക്കുന്നതിനുള്ള നല്ലൊരു മാർഗമാണ്. YAML സ്നിപ്പെറ്റുകൾ റെപ്പോസിറ്ററികൾക്കിടയിൽ പകർത്തുന്നതിനേക്കാൾ.

അത് അമിതമായിരിക്കുമ്പോൾ

എല്ലാ പ്രോജക്റ്റിനും കത്തി വേണ്ടിവരില്ല.

• ലളിതമായ പൈപ്പ്ലൈൻ: നിങ്ങളുടെ പൈപ്പ്ലൈൻ "ടെസ്റ്റുകൾ നടത്തുക, ഇമേജ് നിർമ്മിക്കുക, പുഷ് ചെയ്യുക" ആണെങ്കിൽ, സാധാരണ CI YAML എല്ലാവർക്കും മനസ്സിലാക്കാൻ എളുപ്പമാണ്.
• ടീം കഴിവുകൾ: പൈപ്പ്ലൈനില് തൊടുന്ന എല്ലാവരും തിരഞ്ഞെടുത്ത ഭാഷയില് സുഖമായിരിക്കണം.
• പഠിക്കാനും പ്രവർത്തിപ്പിക്കാനും മറ്റൊരു ഉപകരണം: കത്തി എഞ്ചിൻ എവിടെയായിരുന്നാലും ലഭ്യമായിരിക്കണം, അത് ഇപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുകയാണ്.
• സമുദായ സ്വദേശി സവിശേഷതകൾ മാട്രിക്സ് ബിൽഡുകൾ, പരിതസ്ഥിതികൾ, അംഗീകാരങ്ങൾ എന്നിവ ഇപ്പോഴും നിങ്ങളുടെ ഐ. ഐ. സിസ്റ്റത്തിൽ നിന്നാണ് വരുന്നത്, അതിനാൽ നിങ്ങൾ രണ്ടും ഉപയോഗിക്കും.

സങ്കീർണ്ണമായ പൈപ്പ്ലൈനുകൾ, പല ഘടകങ്ങളുള്ള മോണോറെപ്പോസ്, "ഫിക്സ് സിഐ" കമിറ്റുകളിൽ മടുത്ത ടീമുകൾ, ഒന്നിലധികം സിഐ സംവിധാനങ്ങൾ ഉപയോഗിക്കുന്ന സംഘടനകൾ എന്നിവയാണ് ഇത് പ്രകാശിക്കുന്ന സ്ഥലങ്ങൾ.

അത് പരീക്ഷിക്കാന് മൂല്യവത്താണോ?

നിങ്ങളുടെ പൈപ്പ്ലൈനില് നൂറുകണക്കിന് YAML ലൈനുകളുണ്ടെങ്കിൽ ആരും തൊടാൻ ആഗ്രഹിക്കുന്നില്ല, അതെ. ഒരു സങ്കീർണ്ണമായ ജോലി ഒരു കത്തി ഫംഗ്ഷനിലേക്ക് മാറ്റിക്കൊണ്ട് തുടങ്ങുക. അത് ലോക്കലായി പ്രവർത്തിപ്പിക്കുക. "ദയവായി" എന്ന ലൂപ്പ് ഇല്ലാതായാൽ, നിനക്കറിയാം.

എന്റെ അഭിപ്രായം: പൈപ്പ്ലൈനുകൾ സോഫ്റ്റ് വെയറാണ്. ഡാഗ് നിങ്ങളെ ആ വിധത്തിൽ പെരുമാറാൻ അനുവദിക്കുന്നു, കോഡിന്റെ എല്ലാ ഭാഗങ്ങളിലും ഉപയോഗിക്കുന്ന ഉപകരണങ്ങളുമായി.

ഡെസ്ലി