Kubernetes డ్యాష్‌బోర్డ్ అనేది రన్నింగ్ క్లస్టర్ మరియు దాని కనీస నిర్వహణ గురించి తాజా సమాచారాన్ని పొందడానికి ఉపయోగించడానికి సులభమైన సాధనం. నిర్వాహకులు/DevOps ఇంజనీర్‌లకు మాత్రమే కాకుండా, కన్సోల్‌కు అంతగా అలవాటు లేని మరియు/లేదా kubectlతో పరస్పర చర్య చేయడంలో అన్ని చిక్కులను ఎదుర్కోవడానికి ఉద్దేశించని వారికి కూడా ఈ సామర్థ్యాలకు ప్రాప్యత అవసరమైనప్పుడు మీరు దాన్ని మరింత మెచ్చుకోవడం ప్రారంభిస్తారు. ఇతర వినియోగాలు. ఇది మాతో జరిగింది: డెవలపర్లు Kubernetes వెబ్ ఇంటర్‌ఫేస్‌కు త్వరిత ప్రాప్యతను కోరుకున్నారు మరియు మేము GitLabని ఉపయోగిస్తున్నందున, పరిష్కారం సహజంగానే వచ్చింది.
ఇది ఎందుకు?
డైరెక్ట్ డెవలపర్లు డీబగ్గింగ్ టాస్క్‌ల కోసం K8s డాష్‌బోర్డ్ వంటి సాధనంపై ఆసక్తి కలిగి ఉండవచ్చు. కొన్నిసార్లు మీరు లాగ్‌లు మరియు వనరులను వీక్షించాలని మరియు కొన్నిసార్లు పాడ్‌లను చంపాలని, విస్తరణలు/స్టేట్‌ఫుల్‌సెట్‌లను స్కేల్ చేయండి మరియు కంటైనర్ కన్సోల్‌కి కూడా వెళ్లాలని కోరుకుంటారు (అయితే అభ్యర్థనలు కూడా ఉన్నాయి, అయితే, మరొక మార్గం ఉంది - ఉదాహరణకు, దీని ద్వారా ).
అదనంగా, నిర్వాహకులు క్లస్టర్‌ను చూడాలనుకున్నప్పుడు ఒక మానసిక క్షణం ఉంది - “ప్రతిదీ పచ్చగా ఉంది” అని చూడటానికి, తద్వారా “ప్రతిదీ పని చేస్తోంది” (ఇది చాలా సాపేక్షమైనది... కానీ ఇది వ్యాసం పరిధికి మించినది).
ప్రామాణిక CI వ్యవస్థగా మేము కలిగి ఉన్నాము GitLab: అందరు డెవలపర్లు కూడా దీనిని ఉపయోగిస్తారు. అందువల్ల, వారికి యాక్సెస్‌ను అందించడానికి, డ్యాష్‌బోర్డ్‌ను GitLab ఖాతాలతో ఏకీకృతం చేయడం లాజికల్‌గా ఉంది.
మేము NGINX ప్రవేశాన్ని ఉపయోగిస్తామని కూడా నేను గమనిస్తాను. మీరు ఇతరులతో కలిసి పని చేస్తే , మీరు అధికారం కోసం స్వతంత్రంగా ఉల్లేఖనాల అనలాగ్‌లను కనుగొనవలసి ఉంటుంది.
ఏకీకరణకు ప్రయత్నిస్తున్నారు
డాష్‌బోర్డ్ ఇన్‌స్టాలేషన్
హెచ్చరిక: మీరు దిగువ దశలను పునరావృతం చేయబోతున్నట్లయితే, - అనవసరమైన ఆపరేషన్లను నివారించడానికి - ముందుగా తదుపరి ఉపశీర్షికకు చదవండి.
మేము అనేక ఇన్‌స్టాలేషన్‌లలో ఈ ఇంటిగ్రేషన్‌ని ఉపయోగిస్తాము కాబట్టి, మేము దాని ఇన్‌స్టాలేషన్‌ను ఆటోమేట్ చేసాము. దీనికి అవసరమైన మూలాలు ప్రచురించబడ్డాయి . అవి కొద్దిగా సవరించిన 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శ్రద్ధగల రీడర్ పైన ఉన్న పొడవైన స్ట్రింగ్ కాన్ఫిగర్ నుండి బేస్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కి ఏదైనా యాక్సెస్ ఉన్న వినియోగదారులందరూ డ్యాష్‌బోర్డ్‌కి యాక్సెస్‌ను పొందుతారు. డ్యాష్‌బోర్డ్ హక్కులకు అనుగుణంగా వారు డ్యాష్‌బోర్డ్‌లోనే అదే యాక్సెస్‌ను కలిగి ఉంటారు . సహజంగానే, ఇది అందరికీ తగినది కాదు, కానీ మా విషయంలో ఇది సరిపోతుందని తేలింది.
డాష్‌బోర్డ్‌లోని గుర్తించదగిన ప్రతికూలతలలో, నేను ఈ క్రింది వాటిని గమనించాను:
- init కంటైనర్ యొక్క కన్సోల్‌లోకి ప్రవేశించడం అసాధ్యం;
- విస్తరణలు మరియు స్టేట్‌ఫుల్‌సెట్‌లను సవరించడం అసాధ్యం, అయితే ఇది క్లస్టర్‌రోల్‌లో పరిష్కరించబడుతుంది;
- Kubernetes యొక్క తాజా వెర్షన్‌లతో డాష్‌బోర్డ్ అనుకూలత మరియు ప్రాజెక్ట్ యొక్క భవిష్యత్తు ప్రశ్నలను లేవనెత్తుతుంది.
చివరి సమస్య ప్రత్యేక శ్రద్ధ అవసరం.
డాష్‌బోర్డ్ స్థితి మరియు ప్రత్యామ్నాయాలు
ప్రాజెక్ట్ యొక్క తాజా వెర్షన్‌లో ప్రదర్శించబడిన కుబెర్నెటెస్ విడుదలలతో డాష్‌బోర్డ్ అనుకూలత పట్టిక (), చాలా సంతోషంగా లేదు:
అయినప్పటికీ, ఉంది (ఇప్పటికే జనవరిలో స్వీకరించబడింది) , ఇది K8s 1.13కి మద్దతును ప్రకటించింది. అదనంగా, ప్రాజెక్ట్ సమస్యలలో మీరు K8s 1.14లో ప్యానెల్‌తో పనిచేసే వినియోగదారుల సూచనలను కనుగొనవచ్చు. చివరగా, ప్రాజెక్ట్ యొక్క కోడ్ బేస్ లోకి ఆగవద్దు. కాబట్టి (కనీసం!) ప్రాజెక్ట్ యొక్క వాస్తవ స్థితి అధికారిక అనుకూలత పట్టిక నుండి మొదట కనిపించేంత చెడ్డది కాదు.
చివరగా, డాష్‌బోర్డ్‌కు ప్రత్యామ్నాయాలు ఉన్నాయి. వారందరిలో:
- — ఒక యువ ఇంటర్‌ఫేస్ (మొదటి కమిట్‌లు ఈ సంవత్సరం మార్చికి చెందినవి), ఇది ఇప్పటికే క్లస్టర్ యొక్క ప్రస్తుత స్థితి మరియు దాని వస్తువుల నిర్వహణ యొక్క దృశ్యమాన ప్రాతినిధ్యం వంటి మంచి లక్షణాలను అందిస్తుంది. "రియల్ టైమ్ ఇంటర్‌ఫేస్"గా ఉంచబడింది, ఎందుకంటే మీరు బ్రౌజర్‌లో పేజీని రిఫ్రెష్ చేయాల్సిన అవసరం లేకుండానే ప్రదర్శించబడిన డేటాను స్వయంచాలకంగా నవీకరిస్తుంది.
- - Red Hat OpenShift నుండి ఒక వెబ్ ఇంటర్‌ఫేస్, అయితే, ప్రాజెక్ట్ యొక్క ఇతర డెవలప్‌మెంట్‌లను మీ క్లస్టర్‌కు తీసుకువస్తుంది, ఇది అందరికీ అనుకూలంగా ఉండదు.
- అనేది ఒక ఆసక్తికరమైన ప్రాజెక్ట్, అన్ని క్లస్టర్ ఆబ్జెక్ట్‌లను వీక్షించే సామర్థ్యంతో తక్కువ-స్థాయి (డ్యాష్‌బోర్డ్ కంటే) ఇంటర్‌ఫేస్‌గా రూపొందించబడింది. అయితే, దాని అభివృద్ధి ఆగిపోయినట్లు కనిపిస్తోంది.
- - కేవలం ఇతర రోజు ప్యానెల్ యొక్క విధులను మిళితం చేసే ప్రాజెక్ట్ (క్లస్టర్ యొక్క ప్రస్తుత స్థితిని చూపుతుంది, కానీ దాని వస్తువులను నిర్వహించదు) మరియు స్వయంచాలక "ఉత్తమ అభ్యాసాల ధృవీకరణ" (అందులో నడుస్తున్న డిప్లాయ్‌మెంట్‌ల కాన్ఫిగరేషన్‌ల యొక్క ఖచ్చితత్వం కోసం క్లస్టర్‌ని తనిఖీ చేస్తుంది).
తీర్మానాలకు బదులుగా
డాష్‌బోర్డ్ అనేది మేము అందించే కుబెర్నెట్స్ క్లస్టర్‌ల కోసం ఒక ప్రామాణిక సాధనం. GitLabతో దాని ఏకీకరణ కూడా మా డిఫాల్ట్ ఇన్‌స్టాలేషన్‌లో భాగమైంది, ఎందుకంటే చాలా మంది డెవలపర్లు ఈ ప్యానెల్‌తో కలిగి ఉన్న సామర్థ్యాల గురించి సంతోషిస్తున్నారు.
కుబెర్నెటెస్ డ్యాష్‌బోర్డ్ కాలానుగుణంగా ఓపెన్ సోర్స్ కమ్యూనిటీ నుండి ప్రత్యామ్నాయాలను కలిగి ఉంటుంది (మరియు మేము వాటిని పరిగణనలోకి తీసుకున్నందుకు సంతోషిస్తున్నాము), కానీ ఈ దశలో మేము ఈ పరిష్కారంతో ఉంటాము.
PS
మా బ్లాగులో కూడా చదవండి:
- «";
- «";
- «";
- «".
మూలం: www.habr.com