കുബർനെറ്റസ് വികസനത്തിനായുള്ള സ്കഫോൾഡിന്റെ അവലോകനം

ഒന്നര വർഷം മുമ്പ്, മാർച്ച് 5, 2018 ന്, ഗൂഗിൾ അതിന്റെ ഓപ്പൺ സോഴ്സ് പ്രോജക്റ്റിന്റെ ആദ്യ ആൽഫ പതിപ്പ് CI/CD എന്ന പേരിൽ പുറത്തിറക്കി. സ്കഫോൾഡ്, "ലളിതവും ആവർത്തിക്കാവുന്നതുമായ കുബർനെറ്റസ് വികസനം" സൃഷ്ടിക്കുക എന്നതായിരുന്നു ആരുടെ ലക്ഷ്യം, അതുവഴി ഡവലപ്പർമാർക്ക് ഭരണത്തേക്കാൾ വികസനത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ കഴിയും. സ്കഫോൾഡിനെ കുറിച്ച് രസകരമായത് എന്തായിരിക്കാം? അത് മാറുന്നതുപോലെ, ഡെവലപ്പർ, ഒരുപക്ഷെ ഓപ്പറേഷൻസ് എഞ്ചിനീയർ എന്നിവയ്‌ക്ക് പോലും ഇത് ഒരു ശക്തമായ ഉപകരണമാക്കി മാറ്റാൻ അതിന്റെ സ്ലീവിന് കുറച്ച് തന്ത്രങ്ങളുണ്ട്. പദ്ധതിയെക്കുറിച്ചും അതിന്റെ കഴിവുകളെക്കുറിച്ചും നമുക്ക് പരിചയപ്പെടാം.

NB: വഴിയിൽ, ഞങ്ങളുടെ പൊതുവിൽ സ്കഫോൾഡിനെക്കുറിച്ച് ഞങ്ങൾ ഇതിനകം സംക്ഷിപ്തമായി സംസാരിച്ചു ഡെവലപ്പർ ടൂളുകളുടെ അവലോകനം, അവരുടെ ജീവിതം കുബർനെറ്റുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.

സിദ്ധാന്തം. ഉദ്ദേശ്യവും കഴിവുകളും

അതിനാൽ, പൊതുവായി പറഞ്ഞാൽ, CI/CD സൈക്കിൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള പ്രശ്നം സ്കഫോൾഡ് പരിഹരിക്കുന്നു (ബിൽഡ്, പുഷ്, വിന്യസിക്കുന്ന ഘട്ടങ്ങളിൽ), ഡെവലപ്പർ പ്രോംപ്റ്റ് ഫീഡ്ബാക്ക് വാഗ്ദാനം ചെയ്യുന്നു, അതായത്. തുടർന്നുള്ള കോഡ് മാറ്റങ്ങളുടെ ഫലം വേഗത്തിൽ സ്വീകരിക്കാനുള്ള കഴിവ് - കുബർനെറ്റസ് ക്ലസ്റ്ററിൽ പ്രവർത്തിക്കുന്ന അപ്‌ഡേറ്റ് ചെയ്ത ആപ്ലിക്കേഷന്റെ രൂപത്തിൽ. കൂടാതെ ഇതിന് വ്യത്യസ്ത സർക്യൂട്ടുകളിൽ പ്രവർത്തിക്കാൻ കഴിയും (ദേവ്, സ്റ്റേജ്, പ്രൊഡക്ഷൻ...), ഇതിനായി റോൾഔട്ടിനുള്ള അനുബന്ധ പൈപ്പ്ലൈനുകൾ വിവരിക്കാൻ സ്കഫോൾഡ് സഹായിക്കുന്നു.

സ്കഫോൾഡിന്റെ സോഴ്സ് കോഡ് Go-യിൽ എഴുതിയിരിക്കുന്നു, വിതരണം ചെയ്തത് സൗജന്യ അപ്പാച്ചെ ലൈസൻസിന് കീഴിലുള്ള 2.0 (GitHub).

പ്രധാന പ്രവർത്തനങ്ങളും സവിശേഷതകളും നോക്കാം. ആദ്യത്തേതിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുന്നു:

• CI/CD പൈപ്പ് ലൈനുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ടൂളുകൾ സ്കഫോൾഡ് വാഗ്ദാനം ചെയ്യുന്നു.
• പശ്ചാത്തലത്തിൽ സോഴ്‌സ് കോഡിലെ മാറ്റങ്ങൾ നിരീക്ഷിക്കുന്നതിനും കണ്ടെയ്‌നർ ചിത്രങ്ങളിലേക്ക് കോഡ് കൂട്ടിച്ചേർക്കുന്നതിനും ഈ ചിത്രങ്ങൾ ഡോക്കർ രജിസ്‌ട്രിയിൽ പ്രസിദ്ധീകരിക്കുന്നതിനും അവയെ കുബർനെറ്റസ് ക്ലസ്റ്ററിലേക്ക് വിന്യസിക്കുന്നതിനുമുള്ള ഒരു ഓട്ടോമേറ്റഡ് പ്രോസസ്സ് പ്രവർത്തിപ്പിക്കുന്നതിന് നിങ്ങളെ അനുവദിക്കുന്നു.
• കണ്ടെയ്‌നറിലെ വർക്കിംഗ് ഡയറക്ടറിയുമായി റിപ്പോസിറ്ററിയിലെ ഫയലുകൾ സമന്വയിപ്പിക്കുന്നു.
• കണ്ടെയ്നർ-സ്ട്രക്ചർ-ടെസ്റ്റ് ഉപയോഗിച്ച് യാന്ത്രികമായി പരിശോധിക്കുന്നു.
• ഫോർവേഡ് പോർട്ടുകൾ.
• ഒരു കണ്ടെയ്‌നറിൽ പ്രവർത്തിക്കുന്ന ഒരു ആപ്ലിക്കേഷന്റെ ലോഗുകൾ വായിക്കുന്നു.
• Java, Node.js, Python, Go എന്നിവയിൽ എഴുതിയ ആപ്ലിക്കേഷനുകൾ ഡീബഗ്ഗിംഗ് ചെയ്യാൻ സഹായിക്കുന്നു.

ഇപ്പോൾ സവിശേഷതകളെക്കുറിച്ച്:

• സ്കഫോൾഡിന് തന്നെ ക്ലസ്റ്റർ-സൈഡ് ഘടകങ്ങളില്ല. അതായത്, ഈ യൂട്ടിലിറ്റി ഉപയോഗിക്കുന്നതിന് കുബർനെറ്റുകളെ കൂടുതൽ കോൺഫിഗർ ചെയ്യേണ്ട ആവശ്യമില്ല.
• നിങ്ങളുടെ അപേക്ഷയ്ക്കായി വ്യത്യസ്ത പൈപ്പ് ലൈനുകൾ. നിങ്ങൾ വികസിപ്പിച്ചുകൊണ്ടിരിക്കുമ്പോൾ, പ്രാദേശിക മിനിക്യൂബിലേയ്‌ക്കും തുടർന്ന് സ്റ്റേജിലേക്കോ നിർമ്മാണത്തിലേക്കോ കോഡ് പുറത്തിറക്കേണ്ടതുണ്ടോ? ഈ ആവശ്യത്തിനായി ഉണ്ട് പ്രൊഫൈലുകൾ ഒരു ആപ്ലിക്കേഷനായി വ്യത്യസ്ത പൈപ്പ് ലൈനുകൾ വിവരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഉപയോക്തൃ കോൺഫിഗറേഷനുകൾ, പരിസ്ഥിതി വേരിയബിളുകൾ, ഫ്ലാഗുകൾ.
• CLI. YAML-ൽ കൺസോൾ യൂട്ടിലിറ്റിയും കോൺഫിഗറേഷനുകളും മാത്രം. സൃഷ്ടിക്കാനുള്ള ശ്രമങ്ങളുടെ റഫറൻസുകൾ ഇന്റർനെറ്റിൽ നിങ്ങൾക്ക് കണ്ടെത്താനാകും പരീക്ഷണാത്മക ജിയുഐ, എന്നിരുന്നാലും, ഇപ്പോൾ ഇത് അർത്ഥമാക്കുന്നത് ആർക്കെങ്കിലും അവനെ ആവശ്യമാണെന്നാണ്, പക്ഷേ ശരിക്കും അല്ല.
• മോഡുലാരിറ്റി. സ്കഫോൾഡ് ഒരു ഒറ്റപ്പെട്ട കൊയ്ത്തുകാരൻ അല്ല, എന്നാൽ നിർദ്ദിഷ്ട ടാസ്ക്കുകൾക്കായി വ്യക്തിഗത മൊഡ്യൂളുകളോ നിലവിലുള്ള പരിഹാരങ്ങളോ ഉപയോഗിക്കാൻ ശ്രമിക്കുന്നു.

രണ്ടാമത്തേതിന്റെ ദൃഷ്ടാന്തം:

• അസംബ്ലി ഘട്ടത്തിൽ നിങ്ങൾക്ക് ഉപയോഗിക്കാം:
  • ഡോക്കർ ബിൽഡ് പ്രാദേശികമായി, ഒരു ക്ലസ്റ്ററിൽ കനിക്കോ ഉപയോഗിച്ചോ Google ക്ലൗഡ് ബിൽഡിലോ;
  • പ്രാദേശികമായി ബാസൽ;
  • ജിബ് മാവെനും ജിബ് ഗ്രേഡിലും പ്രാദേശികമായോ Google ക്ലൗഡ് ബിൽഡിലോ;
  • കസ്റ്റം ബിൽഡ് സ്ക്രിപ്റ്റുകൾ പ്രാദേശികമായി പ്രവർത്തിക്കുന്നു. നിങ്ങൾക്ക് മറ്റൊരു (കൂടുതൽ വഴക്കമുള്ള/പരിചിതമായ/...) ബിൽഡ് സൊല്യൂഷൻ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ, അത് സ്‌ക്രിപ്റ്റിൽ വിവരിച്ചിരിക്കുന്നതിനാൽ സ്കഫോൾഡ് അത് സമാരംഭിക്കും (ഡോക്യുമെന്റേഷനിൽ നിന്നുള്ള ഉദാഹരണം). സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് വിളിക്കാവുന്ന ഏത് കളക്ടറും ഉപയോഗിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു;
• പരീക്ഷണ ഘട്ടത്തിൽ, ഇതിനകം സൂചിപ്പിച്ചത് കണ്ടെയ്നർ-സ്ട്രക്ചർ-ടെസ്റ്റ്;
• വിന്യാസത്തിനായി ഇനിപ്പറയുന്നവ നൽകിയിരിക്കുന്നു:
  • കുബെക്ടൽ;
  • ഹെൽം;
  • ഇഷ്ടാനുസൃതമാക്കുക.

ഇതിന് നന്ദി, സ്കഫോൾഡിനെ അദ്വിതീയമെന്ന് വിളിക്കാം CI/CD നിർമ്മിക്കുന്നതിനുള്ള ചട്ടക്കൂട്. ഇത് ഉപയോഗിക്കുമ്പോൾ ഒരു ഉദാഹരണ വർക്ക്ഫ്ലോ ഇതാ (പ്രോജക്റ്റ് ഡോക്യുമെന്റേഷനിൽ നിന്ന്):

സ്കഫോൾഡിന്റെ ജോലി പൊതുവെ എങ്ങനെയിരിക്കും?

1. സോഴ്സ് കോഡ് ഡയറക്ടറിയിലെ മാറ്റങ്ങൾ യൂട്ടിലിറ്റി നിരീക്ഷിക്കുന്നു. ഫയലുകളിൽ മാറ്റങ്ങൾ വരുത്തിയാൽ, അവ കുബർനെറ്റസ് ക്ലസ്റ്ററിലെ ആപ്ലിക്കേഷൻ പോഡുമായി സമന്വയിപ്പിക്കും. സാധ്യമെങ്കിൽ, ചിത്രം വീണ്ടും കൂട്ടിച്ചേർക്കാതെ. അല്ലെങ്കിൽ, ഒരു പുതിയ ചിത്രം കൂട്ടിച്ചേർക്കപ്പെടുന്നു.
2. കണ്ടെയ്‌നർ-സ്ട്രക്ചർ-ടെസ്റ്റ് ഉപയോഗിച്ച് അസംബിൾ ചെയ്‌ത ചിത്രം പരിശോധിച്ച് ടാഗ് ചെയ്‌ത് ഡോക്കർ രജിസ്‌ട്രിയിലേക്ക് അയച്ചു.
3. ഇതിനുശേഷം, ചിത്രം വിന്യസിച്ചു - കുബർനെറ്റസ് ക്ലസ്റ്ററിൽ വിന്യസിച്ചു.
4. കമാൻഡ് ഉപയോഗിച്ചാണ് ലോഞ്ച് ആരംഭിച്ചതെങ്കിൽ skaffold dev, തുടർന്ന് ഞങ്ങൾ ആപ്ലിക്കേഷനിൽ നിന്ന് ലോഗുകൾ സ്വീകരിക്കാൻ തുടങ്ങുന്നു, കൂടാതെ എല്ലാ പ്രവർത്തനങ്ങളും വീണ്ടും ആവർത്തിക്കുന്നതിന് മാറ്റങ്ങൾക്കായി സ്കഫോൾഡ് കാത്തിരിക്കുന്നു.

സ്കഫോൾഡ് പ്രവർത്തനത്തിന്റെ പ്രധാന ഘട്ടങ്ങളുടെ ചിത്രീകരണം

പരിശീലിക്കുക. സ്കഫോൾഡ് ശ്രമിക്കുന്നു

സ്കഫോൾഡിന്റെ ഉപയോഗം തെളിയിക്കാൻ, ഞാൻ ഒരു ഉദാഹരണം എടുക്കും GitHub പ്രോജക്റ്റ് ശേഖരം... വഴിമധ്യേ, അവിടെ വിവിധ പ്രത്യേകതകൾ കണക്കിലെടുക്കുന്ന മറ്റ് നിരവധി ഉദാഹരണങ്ങൾ നിങ്ങൾക്ക് കണ്ടെത്താൻ കഴിയും. എല്ലാ പ്രവർത്തനങ്ങളും ഞാൻ മിനിക്യൂബിൽ പ്രാദേശികമായി നിർവഹിക്കും. ഇൻസ്റ്റാളേഷൻ ലളിതവും കുറച്ച് മിനിറ്റുകൾ എടുക്കുന്നതുമാണ്, ആരംഭിക്കുന്നതിന് നിങ്ങൾക്ക് kubectl ആവശ്യമാണ്.

സ്കഫോൾഡ് ഇൻസ്റ്റാൾ ചെയ്യുക:

curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64
chmod +x skaffold
sudo mv skaffold /usr/local/bin
skaffold version
v0.37.1

ആവശ്യമായ ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് നമുക്ക് സ്കഫോൾഡിന്റെ ശേഖരം ക്ലോൺ ചെയ്യാം:

git clone https://github.com/GoogleContainerTools/skaffold
cd skaffold/examples/microservices

ഞാൻ രണ്ട് പോഡുകൾ ഉള്ള ഒരു ഉദാഹരണം തിരഞ്ഞെടുത്തു, ഓരോന്നിലും ഒരു ചെറിയ Go ആപ്ലിക്കേഷൻ അടങ്ങിയിരിക്കുന്നു. ഒരു ആപ്ലിക്കേഷൻ ഫ്രണ്ട്‌എൻഡ് (leeroy-web) ആണ്, അത് അഭ്യർത്ഥനയെ രണ്ടാമത്തെ ആപ്ലിക്കേഷനിലേക്ക് റീഡയറക്‌ട് ചെയ്യുന്നു - ബാക്കെൻഡ് (leeroy-app). അത് എങ്ങനെയുണ്ടെന്ന് നോക്കാം:

~/skaffold/examples/microservices # tree
.
├── leeroy-app
│   ├── app.go
│   ├── Dockerfile
│   └── kubernetes
│       └── deployment.yaml
├── leeroy-web
│   ├── Dockerfile
│   ├── kubernetes
│   │   └── deployment.yaml
│   └── web.go
├── README.adoc
└── skaffold.yaml
 
4 directories, 8 files

leeroy-app, leeroy-web എന്നിവയിൽ ഗോ കോഡും ഈ കോഡ് പ്രാദേശികമായി നിർമ്മിക്കുന്നതിനുള്ള ലളിതമായ ഡോക്കർഫയലുകളും അടങ്ങിയിരിക്കുന്നു:

~/skaffold/examples/microservices # cat leeroy-app/Dockerfile
FROM golang:1.12.9-alpine3.10 as builder
COPY app.go .
RUN go build -o /app .
 
FROM alpine:3.10
CMD ["./app"]
COPY --from=builder /app .

ഞാൻ ആപ്ലിക്കേഷൻ കോഡ് നൽകില്ല - അത് അറിഞ്ഞാൽ മതി leeroy-web അഭ്യർത്ഥനകൾ സ്വീകരിക്കുകയും അവ പ്രോക്സി ചെയ്യുകയും ചെയ്യുന്നു leeroy-app. അതിനാൽ ഫയലുകളിൽ Deployment.yaml എന്നതിന് മാത്രം ഒരു സേവനം ഉണ്ട് app (ആന്തരിക റൂട്ടിംഗിനായി). പോഡ് പോർട്ട് web ആപ്ലിക്കേഷനിലേക്കുള്ള ദ്രുത പ്രവേശനത്തിനായി ഞങ്ങൾ അത് ഞങ്ങൾക്ക് കൈമാറും.

ഇത് എങ്ങനെയിരിക്കും skaffold.yaml:

~/skaffold/examples/microservices # cat skaffold.yaml
apiVersion: skaffold/v1beta13
kind: Config
build:
  artifacts:
    - image: leeroy-web
      context: ./leeroy-web/
    - image: leeroy-app
      context: ./leeroy-app/
deploy:
  kubectl:
    manifests:
      - ./leeroy-web/kubernetes/*
      - ./leeroy-app/kubernetes/*
portForward:
  - resourceType: deployment
    resourceName: leeroy-web
    port: 8080
    localPort: 9000

മുകളിൽ സൂചിപ്പിച്ച എല്ലാ ഘട്ടങ്ങളും ഇവിടെ വിവരിച്ചിരിക്കുന്നു. ഈ കോൺഫിഗറിനു പുറമേ, ആഗോള ക്രമീകരണങ്ങളുള്ള ഒരു ഫയലും ഉണ്ട് - ~/.skaffold/config. ഇത് സ്വമേധയാ അല്ലെങ്കിൽ CLI വഴി എഡിറ്റുചെയ്യാനാകും - ഉദാഹരണത്തിന്, ഇതുപോലെ:

skaffold config set --global local-cluster true

ഈ കമാൻഡ് ഗ്ലോബൽ വേരിയബിൾ സജ്ജമാക്കും local-cluster അർത്ഥത്തിലേക്ക് true, അതിനുശേഷം സ്കഫോൾഡ് ചിത്രങ്ങൾ റിമോട്ട് രജിസ്ട്രിയിലേക്ക് തള്ളാൻ ശ്രമിക്കില്ല. നിങ്ങൾ പ്രാദേശികമായി വികസിപ്പിക്കുകയാണെങ്കിൽ, പ്രാദേശികമായി ചിത്രങ്ങൾ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് ഈ കമാൻഡ് ഉപയോഗിക്കാം.

തിരികെ skaffold.yaml:

• വേദിയിൽ build നിങ്ങൾ ചിത്രം പ്രാദേശികമായി ശേഖരിക്കുകയും സംരക്ഷിക്കുകയും ചെയ്യണമെന്ന് ഞങ്ങൾ വ്യക്തമാക്കുന്നു. ബിൽഡ് ആദ്യമായി പ്രവർത്തിച്ചതിന് ശേഷം, ഞങ്ങൾ ഇനിപ്പറയുന്നവ കാണും:

  // т.к. Minikube создает кластер в отдельной виртуальной машине,
  // придется проникнуть внутрь, чтобы найти образы
  # minikube ssh
  $ docker images
  REPOSITORY                                TAG                                                                IMAGE ID            CREATED             SIZE 
  leeroy-app                                7d55a50803590b2ff62e47e6f240723451f3ef6f8c89aeb83b34e661aa287d2e   7d55a5080359        4 hours ago         13MB 
  leeroy-app                                v0.37.1-171-g0270a0c-dirty                                         7d55a5080359        4 hours ago         13MB
  leeroy-web                                5063bfb29d984db1ff70661f17d6efcc5537f2bbe6aa6907004ad1ab38879681   5063bfb29d98        5 hours ago         13.1MB
  leeroy-web                                v0.37.1-171-g0270a0c-dirty                                         5063bfb29d98        5 hours ago         13.1MB

  നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, സ്കഫോൾഡ് ചിത്രങ്ങൾ സ്വയം ടാഗ് ചെയ്തു. വഴിയിൽ, നിരവധി ടാഗിംഗ് നയങ്ങൾ പിന്തുണയ്ക്കുന്നു.

• കോൺഫിഗറേഷനിൽ അത് സൂചിപ്പിച്ചിരിക്കുന്നു context: ./leeroy-app/, അതായത്. ചിത്രം ശേഖരിക്കുന്ന സന്ദർഭം വ്യക്തമാക്കിയിട്ടുണ്ട്.
• വിന്യാസ ഘട്ടത്തിൽ, ആവശ്യമായ മാനിഫെസ്റ്റുകൾക്കായി ഞങ്ങൾ kubectl ഉം ഒരു മാസ്കും ഉപയോഗിക്കുമെന്ന് നിർണ്ണയിക്കപ്പെടുന്നു.
• PortForward: ഞങ്ങൾ സാധാരണയായി പോർട്ടുകൾ എങ്ങനെ ഫോർവേഡ് ചെയ്യുന്നു എന്നതിന് സമാനമാണ് kubectl port-forward, ഈ കമാൻഡ് വിളിക്കാൻ ഞങ്ങൾ സ്കഫോൾഡിന് നിർദ്ദേശങ്ങൾ നൽകുന്നു. ഈ സാഹചര്യത്തിൽ, ലോക്കൽ പോർട്ട് 9000 എന്ന പേരിനൊപ്പം വിന്യാസത്തിൽ 8080 ലേക്ക് കൈമാറുന്നു leeroy-web.

ലോഞ്ച് ചെയ്യാൻ സമയമായി skaffold dev: ടീം നിലവിലുള്ള ഒരു "ഫീഡ്ബാക്ക് ലൂപ്പ്" സൃഷ്ടിക്കും, അതായത്. ഇത് എല്ലാം ശേഖരിച്ച് ക്ലസ്റ്ററിലേക്ക് വിന്യസിക്കുമെന്ന് മാത്രമല്ല, ഇപ്പോൾ പോഡുകളുടെ അവസ്ഥയെക്കുറിച്ച് നിങ്ങളോട് പറയും, മാറ്റങ്ങൾ നിരീക്ഷിക്കുകയും പോഡുകളുടെ അവസ്ഥ അപ്‌ഡേറ്റ് ചെയ്യുകയും ചെയ്യും.

ലോഞ്ച് ഫലം ഇതാ skaffold dev --port-forward വീണ്ടും കൂട്ടിച്ചേർക്കുമ്പോൾ:

ആദ്യം, കാഷെ ഉപയോഗിക്കുന്നത് നിങ്ങൾക്ക് കാണാം. അടുത്തതായി, ആപ്ലിക്കേഷൻ കൂട്ടിച്ചേർക്കുകയും വിന്യസിക്കുകയും പോർട്ടുകൾ കൈമാറുകയും ചെയ്യുന്നു. വ്യക്തമാക്കിയത് മുതൽ --port-forward, സ്കാഫോൾഡ് പോർട്ട് ഫോർവേഡ് ചെയ്തു web, അവൻ ചോദിച്ചതുപോലെ, എന്നാൽ ഇവിടെ app അവൻ സ്വന്തം വിവേചനാധികാരത്തിൽ എറിഞ്ഞു (ഏറ്റവും അടുത്തുള്ള സൗജന്യം തിരഞ്ഞെടുത്തു). ഇതിനുശേഷം, ആപ്ലിക്കേഷനുകളിൽ നിന്നുള്ള ആദ്യ ലോഗുകൾ ഞങ്ങൾക്ക് ലഭിക്കും.

ഇത് പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കാം?

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-6998dfcc95-2nxvf   1/1     Running   0          103s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          103s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy app!!!

ഫയൽ പരിഷ്കരിക്കുന്നു leeroy-app/app.go - കുറച്ച് നിമിഷങ്ങൾ കടന്നുപോയി... കൂടാതെ:

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-ffd79d986-l6nwp    1/1     Running   0          11s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          4m59s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy Habr!!!

അതേ സമയം, ഒരു പോയിന്റ് ഒഴികെ, സ്കഫോൾഡ് തന്നെ കൺസോളിൽ മുമ്പത്തെ അതേ കാര്യം പ്രദർശിപ്പിച്ചു: അത് ഉരുട്ടിക്കളഞ്ഞു. leeroy-app, എല്ലാം ഒറ്റയടിക്ക് അല്ല.

കൂടുതൽ പരിശീലനം

ഒരു പുതിയ പ്രോജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ, കമാൻഡ് ഉപയോഗിച്ച് സ്കഫോൾഡിനുള്ള കോൺഫിഗറുകൾ ബൂട്ട്സ്ട്രാപ്പ് ചെയ്യാൻ കഴിയുമെന്നതും എടുത്തുപറയേണ്ടതാണ്. init, ഇത് വളരെ സൗകര്യപ്രദമാണ്. കൂടാതെ, നിങ്ങൾക്ക് നിരവധി കോൺഫിഗേഷനുകൾ എഴുതാം: ഡിഫോൾട്ട് കോൺഫിഗറിൽ വികസനം നടത്തുക, തുടർന്ന് കമാൻഡ് ഉപയോഗിച്ച് സ്റ്റേജിലേക്ക് പുറപ്പെടുക. run (അതേ പ്രക്രിയ dev, മാറ്റങ്ങൾ നിരീക്ഷിക്കുന്നില്ല), മറ്റൊരു കോൺഫിഗറേഷൻ ഉപയോഗിക്കുന്നു.

കാറ്റാക്കോഡയിൽ ഉണ്ട് നേതൃത്വം ഒരു ഉദാഹരണത്തിലൂടെ ഇത് കൂടുതൽ എളുപ്പമാണ്. എന്നാൽ ഇത് കുബർനെറ്റസ്, ഒരു ആപ്ലിക്കേഷനും സ്കഫോൾഡും ഉള്ള ഒരു റെഡിമെയ്ഡ് സാൻഡ്‌ബോക്‌സ് വാഗ്ദാനം ചെയ്യുന്നു. അടിസ്ഥാനകാര്യങ്ങൾ സ്വയം പരീക്ഷിക്കാൻ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ ഒരു മികച്ച ഓപ്ഷൻ.

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

ഒപ്പം ഈ പ്രസിദ്ധീകരണം Weaveworks ൽ നിന്ന് ഉൽപ്പാദനത്തിനായി ഒരു പൈപ്പ്ലൈൻ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം നിങ്ങൾക്ക് കണ്ടെത്താം.

തീരുമാനം

പൈപ്പ് ലൈനുകൾ നിർമ്മിക്കുന്നതിനുള്ള സൗകര്യപ്രദമായ ഉപകരണമാണ് സ്കഫോൾഡ്, അത് കുബെർനെറ്റസിലേക്ക് ആപ്ലിക്കേഷനുകൾ അവതരിപ്പിക്കുന്നതും പ്രാഥമികമായി വികസന ആവശ്യങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നതുമാണ്. ഡവലപ്പറുടെ അടിസ്ഥാന ആവശ്യങ്ങൾ കണക്കിലെടുക്കുന്ന ഒരു "ഹ്രസ്വ" പൈപ്പ്ലൈൻ സൃഷ്ടിക്കുന്നത് വളരെ എളുപ്പമാക്കുന്നു, എന്നാൽ ആവശ്യമെങ്കിൽ, നിങ്ങൾക്ക് വലിയ പ്രക്രിയകൾ സംഘടിപ്പിക്കാൻ കഴിയും. CI/CD പ്രക്രിയകളിൽ സ്കഫോൾഡ് ഉപയോഗിക്കുന്നതിന്റെ വ്യക്തമായ ഉദാഹരണങ്ങളിലൊന്ന് കൊടുത്തു അത്തരമൊരു പരീക്ഷണ പദ്ധതി Kubernetes, gRPC, Istio, OpenCensus Tracing എന്നിവയുടെ കഴിവുകൾ ഉപയോഗിച്ച് 10 മൈക്രോ സർവീസുകൾ.

സ്കഫോൾഡിന് ഇതിനകം തന്നെ GitHub-ൽ ഏകദേശം 8000+ നക്ഷത്രങ്ങളുണ്ട്, ഇത് Google വികസിപ്പിച്ചെടുത്തതാണ്. Google കണ്ടെയ്നർ ടൂളുകൾ - പൊതുവേ, ഈ പ്രോജക്റ്റ് എന്നെന്നേക്കുമായി സന്തോഷത്തോടെ വികസിക്കുമെന്ന് വിശ്വസിക്കാൻ എല്ലാ കാരണവുമുണ്ട്.

പി.എസ്

ഞങ്ങളുടെ ബ്ലോഗിലും വായിക്കുക:

• «Kubernetes-ൽ പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷനുകളുടെ ഡെവലപ്പർമാർക്കുള്ള ഉപകരണങ്ങൾ";
• «werf - കുബർനെറ്റസിലെ CI / CD-യ്ക്കുള്ള ഞങ്ങളുടെ ഉപകരണം (അവലോകനവും വീഡിയോ റിപ്പോർട്ടും)";
• «പൂന്തോട്ടം v0.10.0: നിങ്ങളുടെ ലാപ്‌ടോപ്പിന് കുബർനെറ്റസ് ആവശ്യമില്ല";
• «കുബർനെറ്റസ് നുറുങ്ങുകളും തന്ത്രങ്ങളും: പ്രാദേശിക വികസനത്തെക്കുറിച്ചും ടെലിപ്രെസൻസെക്കുറിച്ചും".

അവലംബം: www.habr.com