ഡെവ ഒപ്സ് എഞ്ചിനീയർമാർ ഗോ പഠിക്കണോ?

നിങ്ങൾ ദിവസവും ഉപയോഗിക്കുന്ന ഉപകരണങ്ങളെ നോക്കൂ: കുബർനെറ്റസ്, ഡോക്കർ, കണ്ടെയ്നർ, ടെറാഫോം, ഓപ്പൺ ടോഫു, ഹെൽം, പ്രോമിത്തേയസ്, ഗ്രാഫാനയുടെ ബാക്ക്എൻഡ്, ആർഗോ സിഡി, ഫ്ലക്സ്, തുടങ്ങിയവ, വോൾട്ട്, ട്രിവി, കെ9സ്. മിക്കവാറും അവയെല്ലാം ഗോയിൽ എഴുതിയിട്ടുണ്ട്.

അതൊരു യാദൃശ്ചികതയല്ല. ഇത് പഠിക്കാന് ഒരു നല്ല കാരണമാണ്.

ഗോ എന്തിന് അടിസ്ഥാന സൌകര്യങ്ങൾ ഏറ്റെടുത്തു?

ഗൂഗിളിൽ സൃഷ്ടിക്കപ്പെട്ടതും 2009 ൽ പുറത്തിറങ്ങിയതുമായ ഗോ വിശ്വസനീയമായ നെറ്റ് വർക്ക് സേവനങ്ങളും ഉപകരണങ്ങളും നിർമ്മിക്കുന്നതിനായി രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. ചില സവിശേഷതകൾ അതിനെ ക്ലൌഡ്-നേറ്റീവ് ഇൻഫ്രാസ്ട്രക്ചറിന്റെ ഭാഷയാക്കി മാറ്റിയിട്ടുണ്ട്:

• ഒറ്റ സ്റ്റാറ്റിക് ബൈനറി. ഒരു Go പ്രോഗ്രാം ഇൻസ്റ്റാൾ ചെയ്യേണ്ട റൺടൈം ഇല്ലാതെ ഒരു ഫയലിലേക്ക് കംപൈൽ ചെയ്യുന്നു. എവിടെ വേണമെങ്കിലും പകര് ത്ത് അത് പ്രവർത്തിപ്പിക്കും. CLI- കളും കണ്ടെയ്നറുകളും ഉപയോഗിക്കാൻ പറ്റിയതാണ്.
• എളുപ്പത്തിൽ ക്രോസ് കോംപൈലേഷൻ. ഒരു മെഷീനിൽ നിന്നും ലിനക്സ്, മാകോസ്, വിൻഡോസ്, എആർഎം, എക്സ്86 എന്നിവയ്ക്കായി നിർമ്മിക്കുക.
• ബിൽറ്റ് ഇൻ സമാനത ഗൊറൂട്ടിൻസും ചാനലുകളും ഉള്ളത്, ഒരേസമയം പല കാര്യങ്ങളും ചെയ്യുന്ന പ്രോഗ്രാമുകൾക്ക് അനുയോജ്യമാണ്, പല വിഭവങ്ങളും നിരീക്ഷിക്കുന്ന കൺട്രോളറുകൾ പോലെ.
• ലളിതമായ ഭാഷ. മനഃപൂർവ്വം ചെറുതും വായിക്കാൻ എളുപ്പമുള്ളതുമായ ഒരു സ്റ്റാൻഡേർഡ് ഫോർമാറ്റിംഗ് ശൈലി (gofmt) നിങ്ങള് ക്ക് മറ്റൊരാളുടെ ഗോ കോഡ് വായിക്കാം അവരുടെ വ്യക്തിപരമായ ശൈലി ഡീകോഡ് ചെയ്യാതെ.
• വേഗത്തിലുള്ള സമാഹരണവും നല്ല പ്രകടനവും.
• ശക്തമായ സ്റ്റാൻഡേർഡ് ലൈബ്രറി HTTP, JSON, ക്രിപ്റ്റോഗ്രാഫി തുടങ്ങിയവയ്ക്കായി.

അത് കൊണ്ട് എന്തു ചെയ്യാം?

ഒരു ഡെവ് ഒപ്സ് എഞ്ചിനീയർ എന്ന നിലയിൽ, ഗോ ചില വാതിലുകൾ തുറക്കുന്നു:

• ഉറവിടം വായിക്കുക നിങ്ങള് ഉപയോഗിക്കുന്ന ഉപകരണങ്ങളുടെ. കുബർനെറ്റസ് അല്ലെങ്കിൽ ടെറാഫോർം വിചിത്രമായി പെരുമാറുമ്പോൾ, കോഡ് വായിക്കുന്നത് പലപ്പോഴും എന്തുകൊണ്ട് എന്ന് മനസിലാക്കാനുള്ള ഏറ്റവും വേഗതയേറിയ മാർഗമാണ്.
• CLI ഉപകരണങ്ങൾ നിർമ്മിക്കുക അത് സഹപ്രവർത്തകര് ക്ക് ഒരൊറ്റ ബൈനറി ആയി ഇൻസ്റ്റാൾ ചെയ്യാം.
• കുബർനെറ്റസ് ഓപ്പറേറ്റർമാരും കൺട്രോളറുകളും എഴുതുക നിങ്ങളുടെ പ്ലാറ്റ്ഫോം ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനായി.
• ടെറഫോർം ദാതാക്കളെ എഴുതുക ആന്തരിക സംവിധാനങ്ങള് ക്ക് വേണ്ടി.
• ഓപ്പൺ സോഴ്സിനു സംഭാവന ചെയ്യുക ക്ലൌഡ് നേറ്റീവ് പ്രോജക്ടുകൾ
• ചെറിയ സേവനങ്ങള് നിര് മിക്കുക: വെബ് ഹൂക്കുകൾ, കയറ്റുമതിക്കാർ, പ്രവേശന നിയന്ത്രകർ.

എന്റെ ആദ്യത്തെ CLI

ഒരു ചെറിയ പക്ഷെ യഥാർത്ഥ ഉദാഹരണം: TLS സർട്ടിഫിക്കറ്റുകൾ കാലഹരണപ്പെടുമ്പോൾ പരിശോധിക്കുന്ന ഒരു CLI.

package main

import (
    "crypto/tls"
    "fmt"
    "os"
    "time"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Fprintln(os.Stderr, "usage: certcheck <host> [host...]")
        os.Exit(1)
    }

    exitCode := 0
    for _, host := range os.Args[1:] {
        conn, err := tls.Dial("tcp", host+":443", &tls.Config{ServerName: host})
        if err != nil {
            fmt.Printf("%-30s ERROR %v\n", host, err)
            exitCode = 1
            continue
        }
        cert := conn.ConnectionState().PeerCertificates[0]
        conn.Close()

        days := int(time.Until(cert.NotAfter).Hours() / 24)
        status := "OK"
        if days < 14 {
            status = "EXPIRING"
            exitCode = 1
        }
        fmt.Printf("%-30s %-8s %d days left\n", host, status, days)
    }
    os.Exit(exitCode)
}

go build -o certcheck .
./certcheck example.com deslypeter.com
GOOS=linux GOARCH=arm64 go build -o certcheck-linux-arm64 .   # cross-compile

സ്റ്റാൻഡേർഡ് ലൈബ്രറിക്ക് പുറത്ത് യാതൊരു ആശ്രയത്വവുമില്ല, ഒരു ബൈനറി, എവിടെയും പ്രവർത്തിക്കുന്നു. വലിയ ക്ലയന്റുകൾക്ക്, ലൈബ്രറികൾ കോബ്ര (കുബെക്ത്ല്, ഹെല്ം തുടങ്ങിയവർ ഉപയോഗിക്കുന്നു) ഉപകമാൻഡുകളും ഫ്ലാഗുകളും ചേർക്കുക.

ഗോ പഠിക്കുന്നത് ഒരു ക്ലൌഡ് അടിസ്ഥാന സൌകര്യത്തിന്റെ മെഷീൻ റൂമിലേക്കുള്ള താക്കോൽ കിട്ടുന്നതു പോലെയാണ്.

ഒരു ചെറിയ കുബർനെറ്റ്സ് ഓപ്പറേറ്റർ

ഓപ്പറേറ്റർമാരുടെ മേഖലയിലാണ് ഗോ പ്ലാറ്റ്ഫോം ജോലിയുടെ കാര്യത്തിൽ തിളങ്ങുന്നത്. ഒരു ഓപ്പറേറ്റര് കുബർനെറ്റിസ് വിഭവങ്ങള് നിരീക്ഷിക്കുകയും അവര് വിവരിച്ച കാര്യങ്ങള് ക്ക് അനുസൃതമായി യാഥാര് ത്ഥ്യം ഉണ്ടാക്കുകയും ചെയ്യുന്നു.

കുബ് ബിൽഡർ (അതിന്റെ അടിസ്ഥാനത്തിൽ നിർമ്മിച്ച ഓപ്പറേറ്റർ എസ്.ഡി.കെ) മിക്ക ബോയിലർപ്ലേറ്റുകളും സൃഷ്ടിക്കുന്നുഃ

kubebuilder init --domain acme.com --repo github.com/acme/app-operator
kubebuilder create api --group platform --version v1alpha1 --kind App

Go ഘടനയില് നിങ്ങളുടെ ഇഷ്ടാനുസൃത റിസോഴ്സിന്റെ ഫീല്ഡുകള് നിര് ണ്ണയിക്കുകയും ഒരു Reconcile ഫംഗ്ഷൻ: "ഇത് കണക്കിലെടുത്തുകൊണ്ട് App ശരിയായ വിന്യാസം, സേവനം, HTTP റൂട്ട് എന്നിവ ഉണ്ടെന്ന് ഉറപ്പാക്കുക". ഈ ചട്ടക്കൂട് നിരീക്ഷണം, കാഷെ ചെയ്യൽ, വീണ്ടും ശ്രമിക്കൽ, നേതാവിനെ തെരഞ്ഞെടുക്കൽ എന്നിവയെല്ലാം കൈകാര്യം ചെയ്യുന്നു.

ഉല്പാദന നിലവാരമുള്ള ഒരു ഓപ്പറേറ്ററെ നിർമ്മിക്കുക എന്നത് ഒരു വാരാന്ത്യ പദ്ധതിയല്ല, പക്ഷേ ഒരു കളിപ്പാട്ടം നിർമ്മിക്കുക എന്നത് കുബർനെറ്റിസ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാനുള്ള ഏറ്റവും നല്ല മാർഗമാണ്. എല്ലാ ബിൽറ്റ്-ഇൻ കൺട്രോളറുകളും ഒരേ മാതൃക പിന്തുടരുന്നു.

DevOps- നായി Go vs Python

അവ പരസ്പര പൂരകങ്ങളാണ്:

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

പല DevOps എൻജിനീയർമാരും സ്ക്രിപ്റ്റുകൾക്കായി പൈത്തൺ ഉപയോഗിക്കുന്നു, ഉപകരണങ്ങൾക്കായി Go ഉപയോഗിക്കുന്നു.

എവിടെ നിന്ന് തുടങ്ങണം?

• ഗോ ടൂർ (go.dev/tour): ഔദ്യോഗിക സംവേദനാത്മക ആമുഖം. കുറച്ചു മണിക്കൂറുകള് .
• മാതൃകയാൽ നടക്കുക: ഓരോ പൊതു ജോലിക്കും ചുരുങ്ങിയ പ്രായോഗിക ഉദാഹരണങ്ങൾ.
• "പഠിക്കുക" ജോൺ ബോഡ്നറുടെ, അല്ലെങ്കിൽ "നമുക്ക് പോകാം" വെബ് സേവനങ്ങൾക്കായി അലക്സ് എഡ്വേർഡ്സ്.
• കുബെബിൽഡർ പുസ്തകം ഓപ്പറേറ്റർമാര് ക്ക് വേണ്ടി
• പിന്നെ നിങ്ങൾ ശരിക്കും ഉപയോഗിക്കുന്ന ചെറിയ എന്തെങ്കിലും നിർമ്മിക്കുക: ഒരു CLI, ഒരു ആന്തരിക സംവിധാനത്തിനുള്ള ഒരു കയറ്റുമതിക്കാരൻ, ഒരു വെബ്ഹുക്ക്.

അത് പഠിക്കണോ?

നിങ്ങൾ കുബർനെറ്റീസുമായി പ്രവർത്തിക്കുകയും ഉപകരണങ്ങൾ ഉപയോഗിക്കുന്നതിലൂടെ അവയെ മനസ്സിലാക്കാനും വിപുലീകരിക്കാനും ആഗ്രഹിക്കുന്നുവെങ്കിൽ, അതെ. ഗോ വിദഗ്ധനാകേണ്ട ആവശ്യമില്ല. ഗോ കോഡ് വായിക്കാനും ചെറിയ ഉപകരണങ്ങൾ എഴുതാനും കഴിയുന്നത് നിങ്ങളെ കൂടുതൽ കാര്യക്ഷമമാക്കുന്നു.

എന്റെ അഭിപ്രായം: നിങ്ങള് സംസാരിക്കേണ്ടതില്ല. ക്ലൌഡ് നേറ്റീവ് ആയി ജോലിക്ക് പോകുക. പക്ഷെ ഇത് അയൽപക്കത്തെ എല്ലാവരും സംസാരിക്കുന്ന ഭാഷയാണ്, അത് സംഭാഷണം മനസ്സിലാക്കാൻ സഹായിക്കുന്നു.

ഡെസ്ലി