ಪ್ರೊಹೋಸ್ಟರ್ > Блог > ಆಡಳಿತ > ಕುಬರ್ನೆಟ್ಸ್ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಮತ್ತು ಗಿಟ್ಲ್ಯಾಬ್ ಬಳಕೆದಾರರ ಏಕೀಕರಣ
ಕುಬರ್ನೆಟ್ಸ್ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಮತ್ತು ಗಿಟ್ಲ್ಯಾಬ್ ಬಳಕೆದಾರರ ಏಕೀಕರಣ
ಕುಬರ್ನೆಟ್ಸ್ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಕ್ಲಸ್ಟರ್ ಮತ್ತು ಅದರ ಕನಿಷ್ಠ ನಿರ್ವಹಣೆಯ ಕುರಿತು ನವೀಕೃತ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ಬಳಸಲು ಸುಲಭವಾದ ಸಾಧನವಾಗಿದೆ. ನಿರ್ವಾಹಕರು/DevOps ಇಂಜಿನಿಯರ್ಗಳು ಮಾತ್ರವಲ್ಲದೆ, ಕನ್ಸೋಲ್ಗೆ ಕಡಿಮೆ ಒಗ್ಗಿಕೊಂಡಿರುವವರು ಮತ್ತು/ಅಥವಾ kubectl ಮತ್ತು ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಎಲ್ಲಾ ಜಟಿಲತೆಗಳನ್ನು ಎದುರಿಸಲು ಉದ್ದೇಶಿಸದವರಿಂದ ಈ ಸಾಮರ್ಥ್ಯಗಳಿಗೆ ಪ್ರವೇಶ ಅಗತ್ಯವಿದ್ದಾಗ ನೀವು ಅದನ್ನು ಇನ್ನಷ್ಟು ಪ್ರಶಂಸಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೀರಿ. ಇತರ ಉಪಯುಕ್ತತೆಗಳು. ಇದು ನಮ್ಮೊಂದಿಗೆ ಸಂಭವಿಸಿದೆ: ಡೆವಲಪರ್ಗಳು ಕುಬರ್ನೆಟ್ಸ್ ವೆಬ್ ಇಂಟರ್ಫೇಸ್ಗೆ ತ್ವರಿತ ಪ್ರವೇಶವನ್ನು ಬಯಸಿದ್ದರು ಮತ್ತು ನಾವು GitLab ಅನ್ನು ಬಳಸುವುದರಿಂದ, ಪರಿಹಾರವು ಸ್ವಾಭಾವಿಕವಾಗಿ ಬಂದಿತು.
ಇದು ಯಾಕೆ?
ಡೀಬಗ್ ಮಾಡುವ ಕಾರ್ಯಗಳಿಗಾಗಿ K8s ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಂತಹ ಸಾಧನದಲ್ಲಿ ನೇರ ಡೆವಲಪರ್ಗಳು ಆಸಕ್ತಿ ಹೊಂದಿರಬಹುದು. ಕೆಲವೊಮ್ಮೆ ನೀವು ಲಾಗ್ಗಳು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ವೀಕ್ಷಿಸಲು ಬಯಸುತ್ತೀರಿ, ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಪಾಡ್ಗಳನ್ನು ಕೊಲ್ಲಲು, ನಿಯೋಜನೆಗಳು/ಸ್ಟೇಟ್ಫುಲ್ಸೆಟ್ಗಳನ್ನು ಸ್ಕೇಲ್ ಮಾಡಲು ಮತ್ತು ಕಂಟೇನರ್ ಕನ್ಸೋಲ್ಗೆ ಹೋಗಿ (ಅದಕ್ಕಾಗಿ ವಿನಂತಿಗಳು ಸಹ ಇವೆ, ಆದಾಗ್ಯೂ, ಇನ್ನೊಂದು ಮಾರ್ಗವಿದೆ - ಉದಾಹರಣೆಗೆ, ಮೂಲಕ kubectl-ಡೀಬಗ್).
ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಿರ್ವಾಹಕರು ಕ್ಲಸ್ಟರ್ ಅನ್ನು ನೋಡಲು ಬಯಸಿದಾಗ ಅವರಿಗೆ ಮಾನಸಿಕ ಕ್ಷಣವಿದೆ - "ಎಲ್ಲವೂ ಹಸಿರು" ಎಂದು ನೋಡಲು, ಮತ್ತು "ಎಲ್ಲವೂ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ" ಎಂದು ತಮ್ಮನ್ನು ತಾವು ಭರವಸೆ ಮಾಡಿಕೊಳ್ಳಿ (ಇದು ಸಹಜವಾಗಿ, ತುಂಬಾ ಸಾಪೇಕ್ಷವಾಗಿದೆ ... ಆದರೆ ಇದು ಲೇಖನದ ವ್ಯಾಪ್ತಿಯನ್ನು ಮೀರಿದೆ ).
ನಾವು ಹೊಂದಿರುವ ಪ್ರಮಾಣಿತ 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 ಹ್ಯಾಶ್ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:
ಅವು ಲಿಪಿಗೆ ವಾದಗಳಾಗಿ ಬಳಸಲ್ಪಡುತ್ತವೆ. ಪರಿಣಾಮವಾಗಿ, ಅನುಸ್ಥಾಪನೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
$ 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
ಆದಾಗ್ಯೂ, ಶೀಘ್ರದಲ್ಲೇ ಅಥವಾ ನಂತರ ಎಲ್ಲವೂ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಅಧಿಕಾರವು ತಕ್ಷಣವೇ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ! ಸತ್ಯವೆಂದರೆ ಬಳಸಿದ ಚಿತ್ರದಲ್ಲಿ (ಇತರ ಚಿತ್ರಗಳಲ್ಲಿನ ಪರಿಸ್ಥಿತಿಯು ಹೋಲುತ್ತದೆ) ಕಾಲ್ಬ್ಯಾಕ್ನಲ್ಲಿ ಮರುನಿರ್ದೇಶನವನ್ನು ಹಿಡಿಯುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ತಪ್ಪಾಗಿ ಅಳವಡಿಸಲಾಗಿದೆ. ಈ ಸನ್ನಿವೇಶವು ಪ್ರಮಾಣವು ಸ್ವತಃ ನಮಗೆ ಒದಗಿಸುವ ಕುಕೀಯನ್ನು ಅಳಿಸುತ್ತದೆ ಎಂಬ ಅಂಶಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ...
ಪ್ಯಾಚ್ನೊಂದಿಗೆ ನಿಮ್ಮ ಸ್ವಂತ ದೃಢೀಕರಣ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತದೆ.
ದೃಢೀಕರಣವನ್ನು ಪ್ಯಾಚ್ ಮಾಡಿ ಮತ್ತು ಮರುಸ್ಥಾಪಿಸಿ
ಇದನ್ನು ಮಾಡಲು, ನಾವು ಈ ಕೆಳಗಿನ ಡಾಕರ್ಫೈಲ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ:
ಮತ್ತು 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
ನೀವು ಅಧಿಕಾರದಿಂದ ಮುಚ್ಚಲ್ಪಟ್ಟ ನೋಂದಾವಣೆ ಹೊಂದಿದ್ದರೆ, ಎಳೆಯುವ ಚಿತ್ರಗಳಿಗಾಗಿ ರಹಸ್ಯದ ಬಳಕೆಯನ್ನು ಸೇರಿಸಲು ಮರೆಯಬೇಡಿ:
ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗೆ ಹೋಗಲು ಮತ್ತು ಪುರಾತನವಾದ ಲಾಗಿನ್ ಬಟನ್ ಅನ್ನು ಹುಡುಕುವ ಸಮಯ ಇದು:
ಅದರ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿದ ನಂತರ, GitLab ನಮ್ಮನ್ನು ಸ್ವಾಗತಿಸುತ್ತದೆ, ಅದರ ಸಾಮಾನ್ಯ ಪುಟಕ್ಕೆ ಲಾಗ್ ಇನ್ ಮಾಡಲು ನೀಡುತ್ತದೆ (ಸಹಜವಾಗಿ, ನಾವು ಈ ಹಿಂದೆ ಅಲ್ಲಿ ಲಾಗ್ ಇನ್ ಮಾಡದಿದ್ದರೆ):
ನಾವು GitLab ರುಜುವಾತುಗಳೊಂದಿಗೆ ಲಾಗ್ ಇನ್ ಮಾಡುತ್ತೇವೆ - ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಮಾಡಲಾಗುತ್ತದೆ:
ಡ್ಯಾಶ್ಬೋರ್ಡ್ ವೈಶಿಷ್ಟ್ಯಗಳ ಬಗ್ಗೆ
ನೀವು ಮೊದಲು ಕುಬರ್ನೆಟ್ಸ್ ಜೊತೆಗೆ ಕೆಲಸ ಮಾಡದ ಡೆವಲಪರ್ ಆಗಿದ್ದರೆ ಅಥವಾ ಕೆಲವು ಕಾರಣಗಳಿಂದ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಅನ್ನು ಮೊದಲು ಎದುರಿಸದಿದ್ದರೆ, ನಾನು ಅದರ ಕೆಲವು ಸಾಮರ್ಥ್ಯಗಳನ್ನು ವಿವರಿಸುತ್ತೇನೆ.
ಮೊದಲನೆಯದಾಗಿ, "ಎಲ್ಲವೂ ಹಸಿರು" ಎಂದು ನೀವು ನೋಡಬಹುದು:
ಪರಿಸರದ ಅಸ್ಥಿರಗಳು, ಡೌನ್ಲೋಡ್ ಮಾಡಿದ ಚಿತ್ರ, ಲಾಂಚ್ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳು ಮತ್ತು ಅವುಗಳ ಸ್ಥಿತಿಯಂತಹ ಪಾಡ್ಗಳಿಗೆ ಹೆಚ್ಚು ವಿವರವಾದ ಡೇಟಾ ಲಭ್ಯವಿದೆ:
ನಿಯೋಜನೆಗಳು ಗೋಚರಿಸುವ ಸ್ಥಿತಿಗಳನ್ನು ಹೊಂದಿವೆ:
ಮತ್ತು ಇತರ ವಿವರಗಳು:
ಮತ್ತು ನಿಯೋಜನೆಯನ್ನು ಅಳೆಯುವ ಸಾಮರ್ಥ್ಯವೂ ಇದೆ:
ಈ ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶ:
ಲೇಖನದ ಆರಂಭದಲ್ಲಿ ಈಗಾಗಲೇ ಉಲ್ಲೇಖಿಸಲಾದ ಇತರ ಉಪಯುಕ್ತ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಲಾಗ್ಗಳನ್ನು ನೋಡುವುದು:
... ಮತ್ತು ಆಯ್ದ ಪಾಡ್ನ ಕಂಟೇನರ್ ಕನ್ಸೋಲ್ಗೆ ಲಾಗ್ ಇನ್ ಮಾಡುವ ಕಾರ್ಯ:
ಉದಾಹರಣೆಗೆ, ನೀವು ನೋಡ್ಗಳಲ್ಲಿನ ಮಿತಿಗಳು/ವಿನಂತಿಗಳನ್ನು ಸಹ ನೋಡಬಹುದು:
ಸಹಜವಾಗಿ, ಇವುಗಳು ಫಲಕದ ಎಲ್ಲಾ ಸಾಮರ್ಥ್ಯಗಳಲ್ಲ, ಆದರೆ ನೀವು ಸಾಮಾನ್ಯ ಕಲ್ಪನೆಯನ್ನು ಪಡೆಯುತ್ತೀರಿ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ಏಕೀಕರಣ ಮತ್ತು ಡ್ಯಾಶ್ಬೋರ್ಡ್ನ ಅನಾನುಕೂಲಗಳು
ವಿವರಿಸಿದ ಏಕೀಕರಣದಲ್ಲಿ ಯಾವುದೇ ಇಲ್ಲ ಪ್ರವೇಶ ನಿಯಂತ್ರಣ. ಇದರೊಂದಿಗೆ, GitLab ಗೆ ಯಾವುದೇ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುವ ಎಲ್ಲಾ ಬಳಕೆದಾರರು ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗೆ ಪ್ರವೇಶವನ್ನು ಪಡೆಯುತ್ತಾರೆ. ಡ್ಯಾಶ್ಬೋರ್ಡ್ನ ಹಕ್ಕುಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಅವರು ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿಯೇ ಅದೇ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದ್ದಾರೆ RBAC ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ನಿಸ್ಸಂಶಯವಾಗಿ, ಇದು ಎಲ್ಲರಿಗೂ ಸೂಕ್ತವಲ್ಲ, ಆದರೆ ನಮ್ಮ ವಿಷಯದಲ್ಲಿ ಇದು ಸಾಕಾಗುತ್ತದೆ.
ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿನ ಗಮನಾರ್ಹ ಅನಾನುಕೂಲಗಳಲ್ಲಿ, ನಾನು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಗಮನಿಸುತ್ತೇನೆ:
init ಕಂಟೇನರ್ನ ಕನ್ಸೋಲ್ಗೆ ಪ್ರವೇಶಿಸುವುದು ಅಸಾಧ್ಯ;
ನಿಯೋಜನೆಗಳು ಮತ್ತು ಸ್ಟೇಟ್ಫುಲ್ಸೆಟ್ಗಳನ್ನು ಸಂಪಾದಿಸುವುದು ಅಸಾಧ್ಯ, ಆದಾಗ್ಯೂ ಇದನ್ನು ಕ್ಲಸ್ಟರ್ರೋಲ್ನಲ್ಲಿ ಸರಿಪಡಿಸಬಹುದು;
ಕುಬರ್ನೆಟ್ಸ್ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳೊಂದಿಗೆ ಡ್ಯಾಶ್ಬೋರ್ಡ್ನ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಯೋಜನೆಯ ಭವಿಷ್ಯವು ಪ್ರಶ್ನೆಗಳನ್ನು ಹುಟ್ಟುಹಾಕುತ್ತದೆ.
ಕೊನೆಯ ಸಮಸ್ಯೆ ವಿಶೇಷ ಗಮನಕ್ಕೆ ಅರ್ಹವಾಗಿದೆ.
ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಸ್ಥಿತಿ ಮತ್ತು ಪರ್ಯಾಯಗಳು
ಯೋಜನೆಯ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾದ ಕುಬರ್ನೆಟ್ಸ್ ಬಿಡುಗಡೆಗಳೊಂದಿಗೆ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಹೊಂದಾಣಿಕೆ ಕೋಷ್ಟಕ (v1.10.1), ತುಂಬಾ ಸಂತೋಷವಾಗಿಲ್ಲ:
ಇದರ ಹೊರತಾಗಿಯೂ, ಇದೆ (ಈಗಾಗಲೇ ಜನವರಿಯಲ್ಲಿ ಅಳವಡಿಸಿಕೊಳ್ಳಲಾಗಿದೆ) PR #3476, ಇದು K8s 1.13 ಗೆ ಬೆಂಬಲವನ್ನು ಪ್ರಕಟಿಸುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಯೋಜನಾ ಸಮಸ್ಯೆಗಳ ನಡುವೆ ನೀವು K8s 1.14 ರಲ್ಲಿ ಫಲಕದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಬಳಕೆದಾರರಿಗೆ ಉಲ್ಲೇಖಗಳನ್ನು ಕಾಣಬಹುದು. ಅಂತಿಮವಾಗಿ, ಒಪ್ಪಿಸುತ್ತಾನೆ ಯೋಜನೆಯ ಕೋಡ್ ಬೇಸ್ ನಿಲ್ಲುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ (ಕನಿಷ್ಠ!) ಯೋಜನೆಯ ನಿಜವಾದ ಸ್ಥಿತಿಯು ಅಧಿಕೃತ ಹೊಂದಾಣಿಕೆಯ ಕೋಷ್ಟಕದಿಂದ ಮೊದಲು ತೋರುವಷ್ಟು ಕೆಟ್ಟದ್ದಲ್ಲ.
ಅಂತಿಮವಾಗಿ, ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗೆ ಪರ್ಯಾಯಗಳಿವೆ. ಅವುಗಳಲ್ಲಿ:
K8Dash — ಯುವ ಇಂಟರ್ಫೇಸ್ (ಮೊದಲ ಕಮಿಟ್ಗಳು ಈ ವರ್ಷದ ಮಾರ್ಚ್ಗೆ ಹಿಂದಿನದು), ಇದು ಈಗಾಗಲೇ ಕ್ಲಸ್ಟರ್ನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯ ದೃಶ್ಯ ಪ್ರಾತಿನಿಧ್ಯ ಮತ್ತು ಅದರ ವಸ್ತುಗಳ ನಿರ್ವಹಣೆಯಂತಹ ಉತ್ತಮ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ. "ನೈಜ-ಸಮಯದ ಇಂಟರ್ಫೇಸ್" ಎಂದು ಇರಿಸಲಾಗಿದೆ, ಏಕೆಂದರೆ ನೀವು ಬ್ರೌಸರ್ನಲ್ಲಿ ಪುಟವನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲದೇ ಪ್ರದರ್ಶಿಸಲಾದ ಡೇಟಾವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನವೀಕರಿಸುತ್ತದೆ.
OpenShift ಕನ್ಸೋಲ್ - Red Hat OpenShift ನಿಂದ ವೆಬ್ ಇಂಟರ್ಫೇಸ್, ಆದಾಗ್ಯೂ, ಯೋಜನೆಯ ಇತರ ಬೆಳವಣಿಗೆಗಳನ್ನು ನಿಮ್ಮ ಕ್ಲಸ್ಟರ್ಗೆ ತರುತ್ತದೆ, ಅದು ಎಲ್ಲರಿಗೂ ಸೂಕ್ತವಲ್ಲ.
ಕುಬರ್ನೇಟರ್ ಎಲ್ಲಾ ಕ್ಲಸ್ಟರ್ ಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ವೀಕ್ಷಿಸುವ ಸಾಮರ್ಥ್ಯದೊಂದಿಗೆ ಕೆಳಮಟ್ಟದ (ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗಿಂತ) ಇಂಟರ್ಫೇಸ್ನಂತೆ ರಚಿಸಲಾದ ಆಸಕ್ತಿದಾಯಕ ಯೋಜನೆಯಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಅದರ ಅಭಿವೃದ್ಧಿಯು ನಿಂತುಹೋದಂತೆ ತೋರುತ್ತಿದೆ.
ಪೋಲಾರಿಸ್ - ಕೇವಲ ಇನ್ನೊಂದು ದಿನ ಘೋಷಿಸಲಾಗಿದೆ ಪ್ಯಾನೆಲ್ನ ಕಾರ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಯೋಜನೆ (ಕ್ಲಸ್ಟರ್ನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ತೋರಿಸುತ್ತದೆ, ಆದರೆ ಅದರ ವಸ್ತುಗಳನ್ನು ನಿರ್ವಹಿಸುವುದಿಲ್ಲ) ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ "ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ಮೌಲ್ಯೀಕರಣ" (ಅದರಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ನಿಯೋಜನೆಗಳ ಸಂರಚನೆಗಳ ಸರಿಯಾದತೆಗಾಗಿ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ).
ತೀರ್ಮಾನಗಳಿಗೆ ಬದಲಾಗಿ
ನಾವು ಸೇವೆ ಸಲ್ಲಿಸುವ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ಗಳಿಗೆ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಪ್ರಮಾಣಿತ ಸಾಧನವಾಗಿದೆ. GitLab ನೊಂದಿಗೆ ಅದರ ಏಕೀಕರಣವು ನಮ್ಮ ಡೀಫಾಲ್ಟ್ ಸ್ಥಾಪನೆಯ ಭಾಗವಾಗಿದೆ, ಏಕೆಂದರೆ ಅನೇಕ ಡೆವಲಪರ್ಗಳು ಈ ಪ್ಯಾನೆಲ್ನೊಂದಿಗೆ ಹೊಂದಿರುವ ಸಾಮರ್ಥ್ಯಗಳ ಬಗ್ಗೆ ಉತ್ಸುಕರಾಗಿದ್ದಾರೆ.
ಕುಬರ್ನೆಟ್ಸ್ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ನಿಯತಕಾಲಿಕವಾಗಿ ಓಪನ್ ಸೋರ್ಸ್ ಸಮುದಾಯದಿಂದ ಪರ್ಯಾಯಗಳನ್ನು ಹೊಂದಿದೆ (ಮತ್ತು ಅವುಗಳನ್ನು ಪರಿಗಣಿಸಲು ನಾವು ಸಂತೋಷಪಡುತ್ತೇವೆ), ಆದರೆ ಈ ಹಂತದಲ್ಲಿ ನಾವು ಈ ಪರಿಹಾರದೊಂದಿಗೆ ಉಳಿಯುತ್ತೇವೆ.