ਕੁਬਰਨੇਟਸ ਡੈਸ਼ਬੋਰਡ ਅਤੇ ਗਿੱਟਲੈਬ ਉਪਭੋਗਤਾਵਾਂ ਦਾ ਏਕੀਕਰਣ

ਕੁਬਰਨੇਟਸ ਡੈਸ਼ਬੋਰਡ ਤੁਹਾਡੇ ਚੱਲ ਰਹੇ ਕਲੱਸਟਰ ਬਾਰੇ ਅੱਪ-ਟੂ-ਡੇਟ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਇਸ ਨੂੰ ਘੱਟੋ-ਘੱਟ ਕੋਸ਼ਿਸ਼ਾਂ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ ਵਰਤੋਂ ਵਿੱਚ ਆਸਾਨ ਟੂਲ ਹੈ। ਤੁਸੀਂ ਇਸਦੀ ਹੋਰ ਵੀ ਪ੍ਰਸ਼ੰਸਾ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦੇ ਹੋ ਜਦੋਂ ਇਹਨਾਂ ਸਮਰੱਥਾਵਾਂ ਤੱਕ ਪਹੁੰਚ ਦੀ ਲੋੜ ਨਾ ਸਿਰਫ਼ ਪ੍ਰਸ਼ਾਸਕਾਂ/DevOps ਇੰਜੀਨੀਅਰਾਂ ਦੁਆਰਾ ਹੁੰਦੀ ਹੈ, ਸਗੋਂ ਉਹਨਾਂ ਦੁਆਰਾ ਵੀ ਜੋ ਕੰਸੋਲ ਦੇ ਘੱਟ ਆਦੀ ਹਨ ਅਤੇ/ਜਾਂ kubectl ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਦੀਆਂ ਸਾਰੀਆਂ ਪੇਚੀਦਗੀਆਂ ਨਾਲ ਨਜਿੱਠਣ ਦਾ ਇਰਾਦਾ ਨਹੀਂ ਰੱਖਦੇ ਹਨ। ਹੋਰ ਉਪਯੋਗਤਾਵਾਂ। ਇਹ ਸਾਡੇ ਨਾਲ ਹੋਇਆ: ਡਿਵੈਲਪਰ ਕੁਬਰਨੇਟਸ ਵੈੱਬ ਇੰਟਰਫੇਸ ਤੱਕ ਤੁਰੰਤ ਪਹੁੰਚ ਚਾਹੁੰਦੇ ਸਨ, ਅਤੇ ਕਿਉਂਕਿ ਅਸੀਂ GitLab ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਹੱਲ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਆਇਆ।

ਇਹ ਕਿਉਂ ਹੈ?

ਡਾਇਰੈਕਟ ਡਿਵੈਲਪਰ ਡੀਬੱਗਿੰਗ ਕਾਰਜਾਂ ਲਈ K8s ਡੈਸ਼ਬੋਰਡ ਵਰਗੇ ਟੂਲ ਵਿੱਚ ਦਿਲਚਸਪੀ ਲੈ ਸਕਦੇ ਹਨ। ਕਈ ਵਾਰ ਤੁਸੀਂ ਲੌਗਸ ਅਤੇ ਸਰੋਤਾਂ ਨੂੰ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ ਕਈ ਵਾਰ ਪੌਡਸ ਨੂੰ ਮਾਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਡਿਪਲਾਇਮੈਂਟਸ/ਸਟੇਟਫੁੱਲਸੈਟਸ ਨੂੰ ਸਕੇਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ ਕੰਟੇਨਰ ਕੰਸੋਲ 'ਤੇ ਵੀ ਜਾਣਾ ਚਾਹੁੰਦੇ ਹੋ (ਇੱਥੇ ਬੇਨਤੀਆਂ ਵੀ ਹਨ, ਹਾਲਾਂਕਿ, ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਹੈ - ਉਦਾਹਰਨ ਲਈ, ਦੁਆਰਾ kubectl-ਡੀਬੱਗ).

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪ੍ਰਬੰਧਕਾਂ ਲਈ ਇੱਕ ਮਨੋਵਿਗਿਆਨਕ ਪਲ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਉਹ ਕਲੱਸਟਰ ਨੂੰ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹਨ - ਇਹ ਦੇਖਣ ਲਈ ਕਿ "ਸਭ ਕੁਝ ਹਰਾ ਹੈ", ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਆਪਣੇ ਆਪ ਨੂੰ ਭਰੋਸਾ ਦਿਵਾਉਂਦਾ ਹੈ ਕਿ "ਸਭ ਕੁਝ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ" (ਜੋ, ਬੇਸ਼ਕ, ਬਹੁਤ ਹੀ ਰਿਸ਼ਤੇਦਾਰ ਹੈ... ਪਰ ਇਹ ਲੇਖ ਦੇ ਦਾਇਰੇ ਤੋਂ ਬਾਹਰ ਹੈ)।

ਇੱਕ ਮਿਆਰੀ CI ਸਿਸਟਮ ਦੇ ਰੂਪ ਵਿੱਚ ਸਾਡੇ ਕੋਲ ਹੈ ਲਾਗੂ ਕੀਤਾ GitLab: ਸਾਰੇ ਡਿਵੈਲਪਰ ਵੀ ਇਸਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਇਸ ਲਈ, ਉਹਨਾਂ ਨੂੰ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ, ਡੈਸ਼ਬੋਰਡ ਨੂੰ GitLab ਖਾਤਿਆਂ ਨਾਲ ਜੋੜਨਾ ਤਰਕਪੂਰਨ ਸੀ।

ਮੈਂ ਇਹ ਵੀ ਨੋਟ ਕਰਾਂਗਾ ਕਿ ਅਸੀਂ NGINX Ingress ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ. ਜੇ ਤੁਸੀਂ ਦੂਜਿਆਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ ਹੱਲ ਹੱਲ, ਤੁਹਾਨੂੰ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਐਨੋਟੇਸ਼ਨਾਂ ਦੇ ਐਨਾਲਾਗਸ ਨੂੰ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਲੱਭਣ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।

ਏਕੀਕਰਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ

ਡੈਸ਼ਬੋਰਡ ਸਥਾਪਨਾ

ਧਿਆਨ ਦਿਓ: ਜੇਕਰ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕਦਮਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਜਾ ਰਹੇ ਹੋ, ਤਾਂ - ਬੇਲੋੜੀ ਕਾਰਵਾਈਆਂ ਤੋਂ ਬਚਣ ਲਈ - ਪਹਿਲਾਂ ਅਗਲੇ ਉਪ ਸਿਰਲੇਖ ਨੂੰ ਪੜ੍ਹੋ।

ਕਿਉਂਕਿ ਅਸੀਂ ਬਹੁਤ ਸਾਰੀਆਂ ਸਥਾਪਨਾਵਾਂ ਵਿੱਚ ਇਸ ਏਕੀਕਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਅਸੀਂ ਇਸਦੀ ਸਥਾਪਨਾ ਨੂੰ ਸਵੈਚਲਿਤ ਕੀਤਾ ਹੈ। ਇਸ ਲਈ ਲੋੜੀਂਦੇ ਸਰੋਤਾਂ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ ਵਿਸ਼ੇਸ਼ GitHub ਰਿਪੋਜ਼ਟਰੀ. ਉਹ ਤੋਂ ਥੋੜੀ ਸੋਧੀਆਂ YAML ਸੰਰਚਨਾਵਾਂ 'ਤੇ ਅਧਾਰਤ ਹਨ ਅਧਿਕਾਰਤ ਡੈਸ਼ਬੋਰਡ ਰਿਪੋਜ਼ਟਰੀ, ਨਾਲ ਹੀ ਤੇਜ਼ ਤੈਨਾਤੀ ਲਈ ਇੱਕ Bash ਸਕ੍ਰਿਪਟ।

ਸਕ੍ਰਿਪਟ ਕਲੱਸਟਰ ਵਿੱਚ ਡੈਸ਼ਬੋਰਡ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ 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 ਵਿੱਚ ਜਾਣ ਦੀ ਲੋੜ ਹੈ: ਐਡਮਿਨ ਖੇਤਰ → ਐਪਲੀਕੇਸ਼ਨ - ਅਤੇ ਭਵਿੱਖ ਦੇ ਪੈਨਲ ਲਈ ਇੱਕ ਨਵੀਂ ਐਪਲੀਕੇਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ। ਚਲੋ ਇਸਨੂੰ "kubernetes ਡੈਸ਼ਬੋਰਡ" ਕਹਿੰਦੇ ਹਾਂ:

ਇਸ ਨੂੰ ਜੋੜਨ ਦੇ ਨਤੀਜੇ ਵਜੋਂ, 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

ਜਲਦੀ ਜਾਂ ਬਾਅਦ ਵਿੱਚ ਸਭ ਕੁਝ ਸ਼ੁਰੂ ਹੋ ਜਾਵੇਗਾ, ਹਾਲਾਂਕਿ ਅਧਿਕਾਰ ਤੁਰੰਤ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ! ਤੱਥ ਇਹ ਹੈ ਕਿ ਵਰਤੇ ਗਏ ਚਿੱਤਰ ਵਿੱਚ (ਹੋਰ ਚਿੱਤਰਾਂ ਵਿੱਚ ਸਥਿਤੀ ਸਮਾਨ ਹੈ) ਕਾਲਬੈਕ ਵਿੱਚ ਇੱਕ ਰੀਡਾਇਰੈਕਟ ਨੂੰ ਫੜਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਗਲਤ ਢੰਗ ਨਾਲ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ. ਇਹ ਸਥਿਤੀ ਇਸ ਤੱਥ ਵੱਲ ਲੈ ਜਾਂਦੀ ਹੈ ਕਿ oauth ਉਸ ਕੂਕੀ ਨੂੰ ਮਿਟਾ ਦਿੰਦਾ ਹੈ ਜੋ ਸਹੁੰ ਖੁਦ ਸਾਨੂੰ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ...

ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਇੱਕ ਪੈਚ ਦੇ ਨਾਲ ਤੁਹਾਡੀ ਆਪਣੀ ਸਹੁੰ ਦੀ ਤਸਵੀਰ ਬਣਾ ਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਪੈਚ ਸਹੁੰ ਚੁੱਕੋ ਅਤੇ ਮੁੜ ਸਥਾਪਿਤ ਕਰੋ

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਡੌਕਰਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ:

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

ਧਿਆਨ ਦੇਣ ਵਾਲਾ ਪਾਠਕ ਇਹ ਦੇਖੇਗਾ ਕਿ ਉਪਰੋਕਤ ਲੰਮੀ ਸਤਰ ਸੰਰਚਨਾ ਤੋਂ ਬੇਸ 64 ਹੈ:

{"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 ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨਾਲ ਲੌਗ ਇਨ ਕਰਦੇ ਹਾਂ - ਅਤੇ ਸਭ ਕੁਝ ਹੋ ਗਿਆ ਹੈ:

ਡੈਸ਼ਬੋਰਡ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ

ਜੇ ਤੁਸੀਂ ਇੱਕ ਡਿਵੈਲਪਰ ਹੋ ਜਿਸਨੇ ਪਹਿਲਾਂ ਕੁਬਰਨੇਟਸ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਜਾਂ ਕਿਸੇ ਕਾਰਨ ਕਰਕੇ ਪਹਿਲਾਂ ਡੈਸ਼ਬੋਰਡ ਦਾ ਸਾਹਮਣਾ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਤਾਂ ਮੈਂ ਇਸ ਦੀਆਂ ਕੁਝ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਦਰਸਾਵਾਂਗਾ।

ਪਹਿਲਾਂ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ "ਸਭ ਕੁਝ ਹਰਾ ਹੈ":

ਪੌਡਾਂ ਲਈ ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਡੇਟਾ ਵੀ ਉਪਲਬਧ ਹੈ, ਜਿਵੇਂ ਕਿ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ, ਡਾਉਨਲੋਡ ਕੀਤਾ ਚਿੱਤਰ, ਲਾਂਚ ਆਰਗੂਮੈਂਟਸ, ਅਤੇ ਉਹਨਾਂ ਦੀ ਸਥਿਤੀ:

ਤੈਨਾਤੀਆਂ ਦੇ ਦ੍ਰਿਸ਼ਮਾਨ ਸਥਿਤੀਆਂ ਹਨ:

...ਅਤੇ ਹੋਰ ਵੇਰਵੇ:

... ਅਤੇ ਤੈਨਾਤੀ ਨੂੰ ਸਕੇਲ ਕਰਨ ਦੀ ਯੋਗਤਾ ਵੀ ਹੈ:

ਇਸ ਕਾਰਵਾਈ ਦਾ ਨਤੀਜਾ:

ਲੇਖ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਜ਼ਿਕਰ ਕੀਤੀਆਂ ਹੋਰ ਉਪਯੋਗੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਲੌਗ ਦੇਖਣਾ ਹੈ:

... ਅਤੇ ਚੁਣੇ ਹੋਏ ਪੋਡ ਦੇ ਕੰਟੇਨਰ ਕੰਸੋਲ ਵਿੱਚ ਲੌਗਇਨ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ:

ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਨੋਡਾਂ 'ਤੇ ਸੀਮਾਵਾਂ/ਬੇਨਤੀਆਂ ਨੂੰ ਵੀ ਦੇਖ ਸਕਦੇ ਹੋ:

ਬੇਸ਼ੱਕ, ਇਹ ਪੈਨਲ ਦੀਆਂ ਸਾਰੀਆਂ ਸਮਰੱਥਾਵਾਂ ਨਹੀਂ ਹਨ, ਪਰ ਮੈਂ ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਆਮ ਵਿਚਾਰ ਪ੍ਰਾਪਤ ਕਰੋਗੇ.

ਏਕੀਕਰਣ ਅਤੇ ਡੈਸ਼ਬੋਰਡ ਦੇ ਨੁਕਸਾਨ

ਵਰਣਿਤ ਏਕੀਕਰਣ ਵਿੱਚ ਕੋਈ ਨਹੀਂ ਹੈ ਪਹੁੰਚ ਕੰਟਰੋਲ. ਇਸਦੇ ਨਾਲ, GitLab ਤੱਕ ਪਹੁੰਚ ਵਾਲੇ ਸਾਰੇ ਉਪਭੋਗਤਾ ਡੈਸ਼ਬੋਰਡ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ। ਉਹਨਾਂ ਕੋਲ ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਵੀ ਉਹੀ ਪਹੁੰਚ ਹੈ, ਜੋ ਕਿ ਡੈਸ਼ਬੋਰਡ ਦੇ ਅਧਿਕਾਰਾਂ ਦੇ ਅਨੁਸਾਰੀ ਹੈ, ਜੋ RBAC ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ. ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਇਹ ਹਰ ਕਿਸੇ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੈ, ਪਰ ਸਾਡੇ ਕੇਸ ਲਈ ਇਹ ਕਾਫ਼ੀ ਸਾਬਤ ਹੋਇਆ.

ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਹੀ ਧਿਆਨ ਦੇਣ ਯੋਗ ਨੁਕਸਾਨਾਂ ਵਿੱਚੋਂ, ਮੈਂ ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਨੋਟ ਕਰਦਾ ਹਾਂ:

• init ਕੰਟੇਨਰ ਦੇ ਕੰਸੋਲ ਵਿੱਚ ਆਉਣਾ ਅਸੰਭਵ ਹੈ;
• ਡਿਪਲਾਇਮੈਂਟਸ ਅਤੇ ਸਟੇਟਫੁਲਸੈੱਟਸ ਨੂੰ ਸੋਧਣਾ ਅਸੰਭਵ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਕਲੱਸਟਰਰੋਲ ਵਿੱਚ ਫਿਕਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ;
• ਕੁਬਰਨੇਟਸ ਦੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣਾਂ ਦੇ ਨਾਲ ਡੈਸ਼ਬੋਰਡ ਦੀ ਅਨੁਕੂਲਤਾ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਭਵਿੱਖ ਸਵਾਲ ਖੜੇ ਕਰਦੇ ਹਨ।

ਆਖਰੀ ਸਮੱਸਿਆ ਵਿਸ਼ੇਸ਼ ਧਿਆਨ ਦੀ ਹੱਕਦਾਰ ਹੈ.

ਡੈਸ਼ਬੋਰਡ ਸਥਿਤੀ ਅਤੇ ਵਿਕਲਪ

Kubernetes ਰੀਲੀਜ਼ਾਂ ਦੇ ਨਾਲ ਡੈਸ਼ਬੋਰਡ ਅਨੁਕੂਲਤਾ ਸਾਰਣੀ, ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਵਿੱਚ ਪੇਸ਼ ਕੀਤੀ ਗਈ (v1.10.1), ਬਹੁਤ ਖੁਸ਼ ਨਹੀਂ:

ਇਸ ਦੇ ਬਾਵਜੂਦ, ਉੱਥੇ ਹੈ (ਪਹਿਲਾਂ ਹੀ ਜਨਵਰੀ ਵਿੱਚ ਅਪਣਾਇਆ ਗਿਆ) ਪੀਆਰ #3476, ਜੋ K8s 1.13 ਲਈ ਸਮਰਥਨ ਦਾ ਐਲਾਨ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪ੍ਰੋਜੈਕਟ ਮੁੱਦਿਆਂ ਵਿੱਚ ਤੁਸੀਂ K8s 1.14 ਵਿੱਚ ਪੈਨਲ ਨਾਲ ਕੰਮ ਕਰਨ ਵਾਲੇ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਹਵਾਲੇ ਲੱਭ ਸਕਦੇ ਹੋ। ਅੰਤ ਵਿੱਚ, ਵਚਨਬੱਧ ਕਰਦਾ ਹੈ ਪ੍ਰੋਜੈਕਟ ਦੇ ਕੋਡ ਬੇਸ ਵਿੱਚ ਨਾ ਰੁਕੋ। ਇਸ ਲਈ (ਘੱਟੋ ਘੱਟ!) ਪ੍ਰੋਜੈਕਟ ਦੀ ਅਸਲ ਸਥਿਤੀ ਇੰਨੀ ਮਾੜੀ ਨਹੀਂ ਹੈ ਜਿੰਨੀ ਇਹ ਪਹਿਲਾਂ ਅਧਿਕਾਰਤ ਅਨੁਕੂਲਤਾ ਸਾਰਣੀ ਤੋਂ ਜਾਪਦੀ ਹੈ.

ਅੰਤ ਵਿੱਚ, ਡੈਸ਼ਬੋਰਡ ਦੇ ਵਿਕਲਪ ਹਨ. ਉਨ੍ਹਾਂ ਦੇ ਵਿੱਚ:

1. K8Dash — ਇੱਕ ਨੌਜਵਾਨ ਇੰਟਰਫੇਸ (ਪਹਿਲਾ ਕਮਿਟ ਇਸ ਸਾਲ ਦੇ ਮਾਰਚ ਤੱਕ ਹੈ), ਜੋ ਪਹਿਲਾਂ ਹੀ ਚੰਗੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਕਲੱਸਟਰ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਅਤੇ ਇਸਦੇ ਆਬਜੈਕਟ ਦੇ ਪ੍ਰਬੰਧਨ ਦੀ ਵਿਜ਼ੂਅਲ ਪ੍ਰਤੀਨਿਧਤਾ। ਇੱਕ "ਰੀਅਲ-ਟਾਈਮ ਇੰਟਰਫੇਸ" ਦੇ ਤੌਰ ਤੇ ਰੱਖਿਆ ਗਿਆ ਹੈ, ਕਿਉਂਕਿ ਤੁਹਾਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਪੰਨੇ ਨੂੰ ਤਾਜ਼ਾ ਕਰਨ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਪ੍ਰਦਰਸ਼ਿਤ ਡੇਟਾ ਨੂੰ ਆਪਣੇ ਆਪ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ।
2. OpenShift ਕੰਸੋਲ - Red Hat OpenShift ਤੋਂ ਇੱਕ ਵੈੱਬ ਇੰਟਰਫੇਸ, ਜੋ ਕਿ, ਪਰ, ਤੁਹਾਡੇ ਕਲੱਸਟਰ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਦੇ ਹੋਰ ਵਿਕਾਸ ਲਿਆਏਗਾ, ਜੋ ਕਿ ਹਰ ਕਿਸੇ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੈ।
3. ਕੁਬਰਨੇਟਰ ਇੱਕ ਦਿਲਚਸਪ ਪ੍ਰੋਜੈਕਟ ਹੈ, ਜੋ ਕਿ ਸਾਰੀਆਂ ਕਲੱਸਟਰ ਆਬਜੈਕਟਾਂ ਨੂੰ ਦੇਖਣ ਦੀ ਯੋਗਤਾ ਦੇ ਨਾਲ ਹੇਠਲੇ-ਪੱਧਰ (ਡੈਸ਼ਬੋਰਡ ਤੋਂ ਵੱਧ) ਇੰਟਰਫੇਸ ਵਜੋਂ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਹਾਲਾਂਕਿ, ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਇਸਦਾ ਵਿਕਾਸ ਰੁਕ ਗਿਆ ਹੈ.
4. ਪੋਲਰਿਸ - ਦੂਜੇ ਦਿਨ ਹੀ ਦਾ ਐਲਾਨ ਕੀਤਾ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਜੋ ਇੱਕ ਪੈਨਲ ਦੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ (ਕਲੱਸਟਰ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਦਿਖਾਉਂਦਾ ਹੈ, ਪਰ ਇਸਦੇ ਆਬਜੈਕਟ ਦਾ ਪ੍ਰਬੰਧਨ ਨਹੀਂ ਕਰਦਾ ਹੈ) ਅਤੇ ਆਟੋਮੈਟਿਕ "ਵਧੀਆ ਅਭਿਆਸਾਂ ਦੀ ਪ੍ਰਮਾਣਿਕਤਾ" (ਇਸ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਤੈਨਾਤੀਆਂ ਦੀਆਂ ਸੰਰਚਨਾਵਾਂ ਦੀ ਸ਼ੁੱਧਤਾ ਲਈ ਕਲੱਸਟਰ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ)।

ਸਿੱਟੇ ਦੀ ਬਜਾਏ

ਡੈਸ਼ਬੋਰਡ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰਾਂ ਲਈ ਇੱਕ ਮਿਆਰੀ ਟੂਲ ਹੈ ਜੋ ਅਸੀਂ ਸੇਵਾ ਕਰਦੇ ਹਾਂ। GitLab ਦੇ ਨਾਲ ਇਸ ਦਾ ਏਕੀਕਰਣ ਵੀ ਸਾਡੀ ਡਿਫੌਲਟ ਸਥਾਪਨਾ ਦਾ ਹਿੱਸਾ ਬਣ ਗਿਆ ਹੈ, ਕਿਉਂਕਿ ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰ ਇਸ ਪੈਨਲ ਨਾਲ ਉਨ੍ਹਾਂ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਬਾਰੇ ਉਤਸ਼ਾਹਿਤ ਹਨ।

ਕੁਬਰਨੇਟਸ ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਓਪਨ ਸੋਰਸ ਕਮਿਊਨਿਟੀ ਤੋਂ ਵਿਕਲਪ ਹੁੰਦੇ ਹਨ (ਅਤੇ ਅਸੀਂ ਉਹਨਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰਨ ਵਿੱਚ ਖੁਸ਼ ਹਾਂ), ਪਰ ਇਸ ਪੜਾਅ 'ਤੇ ਅਸੀਂ ਇਸ ਹੱਲ ਦੇ ਨਾਲ ਰਹਿੰਦੇ ਹਾਂ।

PS

ਸਾਡੇ ਬਲੌਗ 'ਤੇ ਵੀ ਪੜ੍ਹੋ:

• «kubebox ਅਤੇ Kubernetes ਲਈ ਹੋਰ ਸ਼ੈੱਲ";
• «ਕੁਬਰਨੇਟਸ ਅਤੇ ਗਿਟਲੈਬ (ਸਮੀਖਿਆ ਅਤੇ ਵੀਡੀਓ ਰਿਪੋਰਟ) ਦੇ ਨਾਲ ਵਧੀਆ CI/CD ਅਭਿਆਸ";
• «Dapp ਅਤੇ GitLab CI ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Kubernetes ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਓ ਅਤੇ ਤੈਨਾਤ ਕਰੋ";
• «ਉਤਪਾਦਨ ਵਿੱਚ ਨਿਰੰਤਰ ਏਕੀਕਰਣ ਅਤੇ ਡਿਲੀਵਰੀ ਲਈ GitLab CI. ਭਾਗ 1: ਸਾਡੀ ਪਾਈਪਲਾਈਨ".

ਸਰੋਤ: www.habr.com