കുബർനെറ്റസ് ഡാഷ്‌ബോർഡിന്റെയും GitLab ഉപയോക്താക്കളുടെയും സംയോജനം

പ്രവർത്തിക്കുന്ന ക്ലസ്റ്ററിനെയും അതിന്റെ ഏറ്റവും കുറഞ്ഞ മാനേജ്മെന്റിനെയും കുറിച്ചുള്ള കാലികമായ വിവരങ്ങൾ ലഭിക്കുന്നതിനുള്ള എളുപ്പത്തിൽ ഉപയോഗിക്കാവുന്ന ഒരു ഉപകരണമാണ് Kubernetes ഡാഷ്‌ബോർഡ്. അഡ്‌മിനിസ്‌ട്രേറ്റർമാർ/DevOps എഞ്ചിനീയർമാർക്ക് മാത്രമല്ല, കൺസോളുമായി പരിചിതമല്ലാത്തവരും കൂടാതെ/അല്ലെങ്കിൽ kubectl-മായി ഇടപഴകുന്നതിന്റെ എല്ലാ സങ്കീർണതകളും കൈകാര്യം ചെയ്യാൻ ആഗ്രഹിക്കാത്തവരും ഈ കഴിവുകളിലേക്കുള്ള ആക്‌സസ് ആവശ്യമായി വരുമ്പോൾ നിങ്ങൾ അതിനെ കൂടുതൽ അഭിനന്ദിക്കാൻ തുടങ്ങുന്നു. മറ്റ് യൂട്ടിലിറ്റികൾ. ഇത് ഞങ്ങൾക്ക് സംഭവിച്ചു: ഡവലപ്പർമാർക്ക് Kubernetes വെബ് ഇന്റർഫേസിലേക്ക് പെട്ടെന്നുള്ള ആക്സസ് വേണം, ഞങ്ങൾ GitLab ഉപയോഗിക്കുന്നതിനാൽ, പരിഹാരം സ്വാഭാവികമായി വന്നു.

ഇതെന്തുകൊണ്ടാണ്?

ഡീബഗ്ഗിംഗ് ടാസ്‌ക്കുകൾക്കായി K8s ഡാഷ്‌ബോർഡ് പോലുള്ള ഒരു ടൂളിൽ നേരിട്ടുള്ള ഡെവലപ്പർമാർക്ക് താൽപ്പര്യമുണ്ടാകാം. ചിലപ്പോൾ നിങ്ങൾക്ക് ലോഗുകളും ഉറവിടങ്ങളും കാണാനും ചിലപ്പോൾ പോഡ്‌സ് നശിപ്പിക്കാനും വിന്യാസങ്ങൾ/സ്റ്റേറ്റ്‌ഫുൾസെറ്റുകൾ സ്‌കെയിൽ ചെയ്യാനും കണ്ടെയ്‌നർ കൺസോളിലേക്ക് പോകാനും താൽപ്പര്യപ്പെടുന്നു (അതിനും അഭ്യർത്ഥനകളുണ്ട്, എന്നിരുന്നാലും, മറ്റൊരു വഴിയുണ്ട് - ഉദാഹരണത്തിന്, വഴി kubectl-debug).

കൂടാതെ, മാനേജർമാർക്ക് ക്ലസ്റ്ററിലേക്ക് നോക്കാൻ ആഗ്രഹിക്കുമ്പോൾ ഒരു മാനസിക നിമിഷമുണ്ട് - "എല്ലാം പച്ചയാണെന്ന്" കാണാനും അങ്ങനെ "എല്ലാം പ്രവർത്തിക്കുന്നു" എന്ന് സ്വയം ഉറപ്പുനൽകാനും (തീർച്ചയായും, ഇത് വളരെ ആപേക്ഷികമാണ് ... എന്നാൽ ഇത് ലേഖനത്തിന്റെ പരിധിക്കപ്പുറമാണ് ).

ഒരു സാധാരണ CI സിസ്റ്റം എന്ന നിലയിൽ ഞങ്ങൾക്ക് ഉണ്ട് ബാധകമാണ് GitLab: എല്ലാ ഡെവലപ്പർമാരും ഇത് ഉപയോഗിക്കുന്നു. അതിനാൽ, അവർക്ക് ആക്‌സസ് നൽകുന്നതിന്, ഡാഷ്‌ബോർഡിനെ GitLab അക്കൗണ്ടുകളുമായി സംയോജിപ്പിക്കുന്നത് യുക്തിസഹമായിരുന്നു.

ഞങ്ങൾ NGINX പ്രവേശനം ഉപയോഗിക്കുന്നതും ഞാൻ ശ്രദ്ധിക്കും. നിങ്ങൾ മറ്റുള്ളവരുമായി പ്രവർത്തിക്കുകയാണെങ്കിൽ പ്രവേശന പരിഹാരങ്ങൾ, അംഗീകാരത്തിനായി വ്യാഖ്യാനങ്ങളുടെ അനലോഗുകൾ നിങ്ങൾ സ്വതന്ത്രമായി കണ്ടെത്തേണ്ടതുണ്ട്.

സംയോജനം ശ്രമിക്കുന്നു

ഡാഷ്ബോർഡ് ഇൻസ്റ്റാളേഷൻ

ശ്രദ്ധിക്കുക: നിങ്ങൾ ചുവടെയുള്ള ഘട്ടങ്ങൾ ആവർത്തിക്കാൻ പോകുകയാണെങ്കിൽ, - അനാവശ്യ പ്രവർത്തനങ്ങൾ ഒഴിവാക്കാൻ - ആദ്യം അടുത്ത ഉപശീർഷകത്തിലേക്ക് വായിക്കുക.

പല ഇൻസ്റ്റലേഷനുകളിലും ഞങ്ങൾ ഈ സംയോജനം ഉപയോഗിക്കുന്നതിനാൽ, ഞങ്ങൾ അതിന്റെ ഇൻസ്റ്റാളേഷൻ ഓട്ടോമേറ്റ് ചെയ്തിട്ടുണ്ട്. ഇതിനാവശ്യമായ ഉറവിടങ്ങൾ പ്രസിദ്ധീകരിച്ചിട്ടുണ്ട് പ്രത്യേക GitHub ശേഖരം. അവയിൽ നിന്നുള്ള ചെറുതായി പരിഷ്കരിച്ച YAML കോൺഫിഗറേഷനുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ഔദ്യോഗിക ഡാഷ്ബോർഡ് ശേഖരം, അതുപോലെ പെട്ടെന്നുള്ള വിന്യാസത്തിനുള്ള ഒരു ബാഷ് സ്ക്രിപ്റ്റ്.

സ്‌ക്രിപ്റ്റ് ക്ലസ്റ്ററിൽ ഡാഷ്‌ബോർഡ് ഇൻസ്റ്റാൾ ചെയ്യുകയും GitLab-മായി സംയോജിപ്പിക്കുന്നതിനായി കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുന്നു:

$ ./ctl.sh  
Usage: ctl.sh [OPTION]... --gitlab-url GITLAB_URL --oauth2-id ID --oauth2-secret SECRET --dashboard-url DASHBOARD_URL
Install kubernetes-dashboard to Kubernetes cluster.
Mandatory arguments:
 -i, --install                install into 'kube-system' namespace
 -u, --upgrade                upgrade existing installation, will reuse password and host names
 -d, --delete                 remove everything, including the namespace
     --gitlab-url             set gitlab url with schema (https://gitlab.example.com)
     --oauth2-id              set OAUTH2_PROXY_CLIENT_ID from gitlab
     --oauth2-secret          set OAUTH2_PROXY_CLIENT_SECRET from gitlab
     --dashboard-url          set dashboard url without schema (dashboard.example.com)
Optional arguments:
 -h, --help                   output this message

എന്നിരുന്നാലും, ഇത് ഉപയോഗിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾ GitLab: അഡ്മിൻ ഏരിയ → ആപ്ലിക്കേഷനുകളിലേക്ക് പോകേണ്ടതുണ്ട് - കൂടാതെ ഭാവി പാനലിനായി ഒരു പുതിയ ആപ്ലിക്കേഷൻ ചേർക്കുക. നമുക്ക് ഇതിനെ "കുബർനെറ്റസ് ഡാഷ്ബോർഡ്" എന്ന് വിളിക്കാം:

ഇത് ചേർക്കുന്നതിന്റെ ഫലമായി, GitLab ഹാഷുകൾ നൽകും:

അവയാണ് സ്ക്രിപ്റ്റിന്റെ വാദങ്ങളായി ഉപയോഗിക്കുന്നത്. തൽഫലമായി, ഇൻസ്റ്റാളേഷൻ ഇതുപോലെ കാണപ്പെടുന്നു:

$ ./ctl.sh -i --gitlab-url https://gitlab.example.com --oauth2-id 6a52769e… --oauth2-secret 6b79168f… --dashboard-url dashboard.example.com

അതിനുശേഷം, എല്ലാം ആരംഭിച്ചുവെന്ന് പരിശോധിക്കാം:

$ kubectl -n kube-system get pod | egrep '(dash|oauth)'
kubernetes-dashboard-76b55bc9f8-xpncp   1/1       Running   0          14s
oauth2-proxy-5586ccf95c-czp2v           1/1       Running   0          14s

എന്നിരുന്നാലും, താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട് എല്ലാം ആരംഭിക്കും അംഗീകാരം ഉടനടി പ്രവർത്തിക്കില്ല! ഉപയോഗിച്ച ചിത്രത്തിൽ (മറ്റ് ചിത്രങ്ങളിലെ സാഹചര്യം സമാനമാണ്) കോൾബാക്കിൽ ഒരു റീഡയറക്ട് പിടിക്കുന്ന പ്രക്രിയ തെറ്റായി നടപ്പിലാക്കുന്നു എന്നതാണ് വസ്തുത. ഈ സാഹചര്യം ഒൗത്ത് തന്നെ നമുക്ക് നൽകുന്ന കുക്കിയെ ഇല്ലാതാക്കുന്നു എന്ന വസ്തുതയിലേക്ക് നയിക്കുന്നു...

ഒരു പാച്ച് ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം ഓത്ത് ഇമേജ് നിർമ്മിക്കുന്നതിലൂടെ പ്രശ്നം പരിഹരിക്കപ്പെടുന്നു.

ഓത്ത് പാച്ച് വീണ്ടും ഇൻസ്റ്റാൾ ചെയ്യുക

ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഇനിപ്പറയുന്ന ഡോക്കർഫയൽ ഉപയോഗിക്കും:

FROM golang:1.9-alpine3.7
WORKDIR /go/src/github.com/bitly/oauth2_proxy

RUN apk --update add make git build-base curl bash ca-certificates wget 
&& update-ca-certificates 
&& curl -sSO https://raw.githubusercontent.com/pote/gpm/v1.4.0/bin/gpm 
&& chmod +x gpm 
&& mv gpm /usr/local/bin
RUN git clone https://github.com/bitly/oauth2_proxy.git . 
&& git checkout bfda078caa55958cc37dcba39e57fc37f6a3c842  
ADD rd.patch .
RUN patch -p1 < rd.patch 
&& ./dist.sh

FROM alpine:3.7
RUN apk --update add curl bash  ca-certificates && update-ca-certificates
COPY --from=0 /go/src/github.com/bitly/oauth2_proxy/dist/ /bin/

EXPOSE 8080 4180
ENTRYPOINT [ "/bin/oauth2_proxy" ]
CMD [ "--upstream=http://0.0.0.0:8080/", "--http-address=0.0.0.0:4180" ]

rd.patch പാച്ച് തന്നെ എങ്ങനെയായിരിക്കുമെന്ന് ഇതാ

diff --git a/dist.sh b/dist.sh
index a00318b..92990d4 100755
--- a/dist.sh
+++ b/dist.sh
@@ -14,25 +14,13 @@ goversion=$(go version | awk '{print $3}')
sha256sum=()
 
echo "... running tests"
-./test.sh
+#./test.sh
 
-for os in windows linux darwin; do
-    echo "... building v$version for $os/$arch"
-    EXT=
-    if [ $os = windows ]; then
-        EXT=".exe"
-    fi
-    BUILD=$(mktemp -d ${TMPDIR:-/tmp}/oauth2_proxy.XXXXXX)
-    TARGET="oauth2_proxy-$version.$os-$arch.$goversion"
-    FILENAME="oauth2_proxy-$version.$os-$arch$EXT"
-    GOOS=$os GOARCH=$arch CGO_ENABLED=0 
-        go build -ldflags="-s -w" -o $BUILD/$TARGET/$FILENAME || exit 1
-    pushd $BUILD/$TARGET
-    sha256sum+=("$(shasum -a 256 $FILENAME || exit 1)")
-    cd .. && tar czvf $TARGET.tar.gz $TARGET
-    mv $TARGET.tar.gz $DIR/dist
-    popd
-done
+os='linux'
+echo "... building v$version for $os/$arch"
+TARGET="oauth2_proxy-$version.$os-$arch.$goversion"
+GOOS=$os GOARCH=$arch CGO_ENABLED=0 
+    go build -ldflags="-s -w" -o ./dist/oauth2_proxy || exit 1
  
checksum_file="sha256sum.txt"
cd $DIR/dists
diff --git a/oauthproxy.go b/oauthproxy.go
index 21e5dfc..df9101a 100644
--- a/oauthproxy.go
+++ b/oauthproxy.go
@@ -381,7 +381,9 @@ func (p *OAuthProxy) SignInPage(rw http.ResponseWriter, req *http.Request, code
       if redirect_url == p.SignInPath {
               redirect_url = "/"
       }
-
+       if req.FormValue("rd") != "" {
+               redirect_url = req.FormValue("rd")
+       }
       t := struct {
               ProviderName  string
               SignInMessage string

ഇപ്പോൾ നിങ്ങൾക്ക് ചിത്രം നിർമ്മിക്കാനും ഞങ്ങളുടെ GitLab-ലേക്ക് തള്ളാനും കഴിയും. അടുത്തത് manifests/kube-dashboard-oauth2-proxy.yaml ആവശ്യമുള്ള ചിത്രത്തിന്റെ ഉപയോഗം സൂചിപ്പിക്കുക (അത് നിങ്ങളുടേത് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക):

 image: docker.io/colemickens/oauth2_proxy:latest

നിങ്ങൾക്ക് അംഗീകാരത്താൽ അടച്ച ഒരു രജിസ്ട്രി ഉണ്ടെങ്കിൽ, ചിത്രങ്ങൾ വലിച്ചിടുന്നതിന് ഒരു രഹസ്യം ചേർക്കാൻ മറക്കരുത്:

      imagePullSecrets:
     - name: gitlab-registry

... കൂടാതെ രജിസ്ട്രിക്കായി രഹസ്യം തന്നെ ചേർക്കുക:

---
apiVersion: v1
data:
 .dockercfg: eyJyZWdpc3RyeS5jb21wYW55LmNvbSI6IHsKICJ1c2VybmFtZSI6ICJvYXV0aDIiLAogInBhc3N3b3JkIjogIlBBU1NXT1JEIiwKICJhdXRoIjogIkFVVEhfVE9LRU4iLAogImVtYWlsIjogIm1haWxAY29tcGFueS5jb20iCn0KfQoK
=
kind: Secret
metadata:
 annotations:
 name: gitlab-registry
 namespace: kube-system
type: kubernetes.io/dockercfg

മുകളിലെ നീളമുള്ള സ്ട്രിംഗ് കോൺഫിഗറിൽ നിന്ന് base64 ആണെന്ന് ശ്രദ്ധയുള്ള വായനക്കാരൻ കാണും:

{"registry.company.com": {
 "username": "oauth2",
 "password": "PASSWORD",
 "auth": "AUTH_TOKEN",
 "email": "[email protected]"
}
}

ഇതാണ് GitLab-ലെ ഉപയോക്തൃ ഡാറ്റ, Kubernetes കോഡ് രജിസ്ട്രിയിൽ നിന്ന് ചിത്രം പിൻവലിക്കും.

എല്ലാം ചെയ്തുകഴിഞ്ഞാൽ, കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് നിലവിലുള്ള (ശരിയായി പ്രവർത്തിക്കുന്നില്ല) ഡാഷ്‌ബോർഡ് ഇൻസ്റ്റാളേഷൻ നീക്കംചെയ്യാം:

$ ./ctl.sh -d

... കൂടാതെ എല്ലാം വീണ്ടും ഇൻസ്റ്റാൾ ചെയ്യുക:

$ ./ctl.sh -i --gitlab-url https://gitlab.example.com --oauth2-id 6a52769e… --oauth2-secret 6b79168f… --dashboard-url dashboard.example.com

ഡാഷ്‌ബോർഡിലേക്ക് പോയി ഒരു പുരാതന ലോഗിൻ ബട്ടൺ കണ്ടെത്താനുള്ള സമയമാണിത്:

അതിൽ ക്ലിക്കുചെയ്തതിനുശേഷം, GitLab ഞങ്ങളെ സ്വാഗതം ചെയ്യും, അതിന്റെ സാധാരണ പേജിലേക്ക് ലോഗിൻ ചെയ്യാൻ വാഗ്ദാനം ചെയ്യുന്നു (തീർച്ചയായും, ഞങ്ങൾ മുമ്പ് അവിടെ ലോഗിൻ ചെയ്തിട്ടില്ലെങ്കിൽ):

ഞങ്ങൾ GitLab ക്രെഡൻഷ്യലുകൾ ഉപയോഗിച്ച് ലോഗിൻ ചെയ്യുന്നു - എല്ലാം പൂർത്തിയായി:

ഡാഷ്‌ബോർഡ് ഫീച്ചറുകളെ കുറിച്ച്

നിങ്ങൾ മുമ്പ് Kubernetes-ൽ പ്രവർത്തിച്ചിട്ടില്ലാത്ത ഒരു ഡെവലപ്പർ ആണെങ്കിൽ അല്ലെങ്കിൽ ചില കാരണങ്ങളാൽ മുമ്പ് ഡാഷ്ബോർഡ് നേരിട്ടിട്ടില്ലെങ്കിൽ, അതിന്റെ ചില കഴിവുകൾ ഞാൻ ചിത്രീകരിക്കും.

ഒന്നാമതായി, "എല്ലാം പച്ചയാണ്" എന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും:

എൻവയോൺമെന്റ് വേരിയബിളുകൾ, ഡൗൺലോഡ് ചെയ്‌ത ചിത്രം, ലോഞ്ച് ആർഗ്യുമെന്റുകൾ, അവയുടെ അവസ്ഥ എന്നിവ പോലുള്ള പോഡുകൾക്കായി കൂടുതൽ വിശദമായ ഡാറ്റയും ലഭ്യമാണ്:

വിന്യാസങ്ങൾക്ക് ദൃശ്യമായ നിലകളുണ്ട്:

...കൂടാതെ മറ്റ് വിശദാംശങ്ങളും:

... കൂടാതെ വിന്യാസം അളക്കാനുള്ള കഴിവും ഉണ്ട്:

ഈ പ്രവർത്തനത്തിന്റെ ഫലം:

ലേഖനത്തിന്റെ തുടക്കത്തിൽ ഇതിനകം സൂചിപ്പിച്ച മറ്റ് ഉപയോഗപ്രദമായ സവിശേഷതകളിൽ ലോഗുകൾ കാണുന്നതാണ്:

... കൂടാതെ തിരഞ്ഞെടുത്ത പോഡിന്റെ കണ്ടെയ്‌നർ കൺസോളിലേക്ക് ലോഗിൻ ചെയ്യുന്നതിനുള്ള പ്രവർത്തനവും:

ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് നോഡുകളിലെ പരിധികൾ/അഭ്യർത്ഥനകൾ നോക്കാം:

തീർച്ചയായും, ഇവയെല്ലാം പാനലിന്റെ കഴിവുകളല്ല, പക്ഷേ നിങ്ങൾക്ക് പൊതുവായ ആശയം ലഭിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

സംയോജനത്തിന്റെയും ഡാഷ്‌ബോർഡിന്റെയും പോരായ്മകൾ

വിവരിച്ച ഏകീകരണത്തിൽ ഇല്ല പ്രവേശന നിയന്ത്രണം. ഇത് ഉപയോഗിച്ച്, GitLab-ലേക്ക് ഏതെങ്കിലും ആക്‌സസ് ഉള്ള എല്ലാ ഉപയോക്താക്കളും ഡാഷ്‌ബോർഡിലേക്ക് ആക്‌സസ് നേടുന്നു. ഡാഷ്‌ബോർഡിന്റെ അവകാശങ്ങൾക്ക് അനുസൃതമായി ഡാഷ്‌ബോർഡിൽ തന്നെ അവർക്ക് ഒരേ ആക്‌സസ് ഉണ്ട് RBAC-ൽ നിർവചിച്ചിരിക്കുന്നു. വ്യക്തമായും, ഇത് എല്ലാവർക്കും അനുയോജ്യമല്ല, പക്ഷേ ഞങ്ങളുടെ കാര്യത്തിൽ ഇത് മതിയാകും.

ഡാഷ്‌ബോർഡിലെ തന്നെ ശ്രദ്ധേയമായ പോരായ്മകളിൽ, ഞാൻ ഇനിപ്പറയുന്നവ ശ്രദ്ധിക്കുന്നു:

• init കണ്ടെയ്‌നറിന്റെ കൺസോളിൽ പ്രവേശിക്കുന്നത് അസാധ്യമാണ്;
• ഡിപ്ലോയ്‌മെന്റുകളും സ്റ്റേറ്റ്‌ഫുൾസെറ്റുകളും എഡിറ്റുചെയ്യുന്നത് അസാധ്യമാണ്, എന്നിരുന്നാലും ഇത് ക്ലസ്റ്റർറോളിൽ ശരിയാക്കാം;
• കുബർനെറ്റസിന്റെ ഏറ്റവും പുതിയ പതിപ്പുകളുമായുള്ള ഡാഷ്‌ബോർഡിന്റെ അനുയോജ്യതയും പ്രോജക്റ്റിന്റെ ഭാവിയും ചോദ്യങ്ങൾ ഉയർത്തുന്നു.

അവസാന പ്രശ്നം പ്രത്യേക ശ്രദ്ധ അർഹിക്കുന്നു.

ഡാഷ്‌ബോർഡ് നിലയും ഇതര മാർഗങ്ങളും

പ്രോജക്റ്റിന്റെ ഏറ്റവും പുതിയ പതിപ്പിൽ അവതരിപ്പിച്ച കുബർനെറ്റസ് റിലീസുകളുള്ള ഡാഷ്‌ബോർഡ് അനുയോജ്യതാ പട്ടിക (v1.10.1), വളരെ സന്തോഷമില്ല:

ഇതൊക്കെയാണെങ്കിലും, ഉണ്ട് (ഇതിനകം ജനുവരിയിൽ സ്വീകരിച്ചത്) PR # 3476, ഇത് K8s 1.13-നുള്ള പിന്തുണ പ്രഖ്യാപിക്കുന്നു. കൂടാതെ, പ്രോജക്റ്റ് പ്രശ്നങ്ങളിൽ, പാനലിൽ പ്രവർത്തിക്കുന്ന ഉപയോക്താക്കളുടെ റഫറൻസുകൾ K8s 1.14-ൽ നിങ്ങൾക്ക് കണ്ടെത്താനാകും. ഒടുവിൽ, ചെയ്യുന്നു പ്രോജക്റ്റിന്റെ കോഡ് ബേസിലേക്ക് പ്രവേശിക്കുന്നത് നിർത്തരുത്. അതിനാൽ (കുറഞ്ഞത്!) പ്രോജക്റ്റിന്റെ യഥാർത്ഥ നില, ഔദ്യോഗിക അനുയോജ്യതാ പട്ടികയിൽ നിന്ന് ആദ്യം തോന്നിയേക്കാവുന്നത്ര മോശമല്ല.

അവസാനമായി, ഡാഷ്ബോർഡിന് ഇതരമാർഗങ്ങളുണ്ട്. അവർക്കിടയിൽ:

1. കെ8ഡാഷ് — ഒരു യുവ ഇന്റർഫേസ് (ആദ്യത്തെ കമ്മിറ്റ് ഈ വർഷം മാർച്ചിലാണ്), ഇത് ക്ലസ്റ്ററിന്റെ നിലവിലെ അവസ്ഥയുടെയും അതിന്റെ ഒബ്‌ജക്റ്റുകളുടെ മാനേജ്‌മെന്റിന്റെയും വിഷ്വൽ പ്രാതിനിധ്യം പോലുള്ള നല്ല സവിശേഷതകൾ ഇതിനകം വാഗ്ദാനം ചെയ്യുന്നു. ഒരു "തത്സമയ ഇന്റർഫേസ്" ആയി സ്ഥാപിച്ചു, കാരണം ബ്രൗസറിൽ പേജ് പുതുക്കേണ്ട ആവശ്യമില്ലാതെ തന്നെ പ്രദർശിപ്പിച്ച ഡാറ്റ യാന്ത്രികമായി അപ്ഡേറ്റ് ചെയ്യുന്നു.
2. ഓപ്പൺഷിഫ്റ്റ് കൺസോൾ - Red Hat OpenShift-ൽ നിന്നുള്ള ഒരു വെബ് ഇന്റർഫേസ്, എന്നിരുന്നാലും, പ്രോജക്റ്റിന്റെ മറ്റ് സംഭവവികാസങ്ങൾ നിങ്ങളുടെ ക്ലസ്റ്ററിലേക്ക് കൊണ്ടുവരും, ഇത് എല്ലാവർക്കും അനുയോജ്യമല്ല.
3. കുബേർനേറ്റർ എല്ലാ ക്ലസ്റ്റർ ഒബ്‌ജക്‌റ്റുകളും കാണാനുള്ള കഴിവുള്ള ഒരു താഴ്ന്ന നിലയിലുള്ള (ഡാഷ്‌ബോർഡിനേക്കാൾ) ഇന്റർഫേസായി സൃഷ്‌ടിച്ച ഒരു രസകരമായ പ്രോജക്റ്റാണ്. എന്നിരുന്നാലും, അതിന്റെ വികസനം നിലച്ചതായി തോന്നുന്നു.
4. പോളാരിസ് - കഴിഞ്ഞ ദിവസം പ്രഖ്യാപിച്ചു ഒരു പാനലിന്റെ പ്രവർത്തനങ്ങൾ സംയോജിപ്പിക്കുന്ന ഒരു പ്രോജക്റ്റ് (ക്ലസ്റ്ററിന്റെ നിലവിലെ അവസ്ഥ കാണിക്കുന്നു, പക്ഷേ അതിന്റെ ഒബ്ജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നില്ല), യാന്ത്രിക "മികച്ച സമ്പ്രദായങ്ങളുടെ മൂല്യനിർണ്ണയം" (അതിൽ പ്രവർത്തിക്കുന്ന വിന്യാസങ്ങളുടെ കോൺഫിഗറേഷനുകളുടെ കൃത്യതയ്ക്കായി ക്ലസ്റ്റർ പരിശോധിക്കുന്നു).

നിഗമനങ്ങൾക്ക് പകരം

ഞങ്ങൾ സേവിക്കുന്ന കുബർനെറ്റസ് ക്ലസ്റ്ററുകൾക്കുള്ള ഒരു സാധാരണ ഉപകരണമാണ് ഡാഷ്‌ബോർഡ്. പല ഡെവലപ്പർമാരും ഈ പാനലിൽ ഉള്ള കഴിവുകളിൽ ആവേശഭരിതരായതിനാൽ GitLab-മായുള്ള അതിന്റെ സംയോജനവും ഞങ്ങളുടെ ഡിഫോൾട്ട് ഇൻസ്റ്റാളേഷന്റെ ഭാഗമായി മാറിയിരിക്കുന്നു.

കുബർനെറ്റസ് ഡാഷ്‌ബോർഡിന് ഓപ്പൺ സോഴ്‌സ് കമ്മ്യൂണിറ്റിയിൽ നിന്ന് ആനുകാലികമായി ഇതരമാർഗങ്ങളുണ്ട് (അവ പരിഗണിക്കുന്നതിൽ ഞങ്ങൾക്ക് സന്തോഷമുണ്ട്), എന്നാൽ ഈ ഘട്ടത്തിൽ ഞങ്ങൾ ഈ പരിഹാരത്തിൽ തുടരുന്നു.

പി.എസ്

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

• «kubebox ഉം Kubernetes-നുള്ള മറ്റ് ഷെല്ലുകളും";
• «Kubernetes, GitLab എന്നിവയ്‌ക്കൊപ്പമുള്ള മികച്ച CI/CD പരിശീലനങ്ങൾ (അവലോകനവും വീഡിയോ റിപ്പോർട്ടും)";
• «dapp, GitLab CI എന്നിവ ഉപയോഗിച്ച് Kubernetes-ൽ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുകയും വിന്യസിക്കുകയും ചെയ്യുക";
• «ഉൽപ്പാദനത്തിൽ തുടർച്ചയായ സംയോജനത്തിനും വിതരണത്തിനുമായി GitLab CI. ഭാഗം 1: ഞങ്ങളുടെ പൈപ്പ്ലൈൻ".

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