Istio માટે અરજી તૈયાર કરી રહ્યા છીએ

Istio એ વિતરિત એપ્લિકેશનને કનેક્ટ કરવા, સુરક્ષિત કરવા અને મોનિટર કરવા માટેનું એક અનુકૂળ સાધન છે. Istio સ્કેલ પર સોફ્ટવેર ચલાવવા અને મેનેજ કરવા માટે વિવિધ તકનીકોનો ઉપયોગ કરે છે, જેમાં એપ્લિકેશન કોડને પેકેજ કરવા માટે કન્ટેનર અને જમાવટ માટે નિર્ભરતાઓ અને તે કન્ટેનરનું સંચાલન કરવા માટે કુબરનેટ્સનો સમાવેશ થાય છે. તેથી, Istio સાથે કામ કરવા માટે તમારે જાણવું જોઈએ કે આ તકનીકો પર આધારિત બહુવિધ સેવાઓ સાથેની એપ્લિકેશન કેવી રીતે કાર્ય કરે છે વિના ઇસ્ટિઓ. જો આ સાધનો અને વિભાવનાઓ તમને પહેલેથી જ પરિચિત છે, તો આ ટ્યુટોરીયલને અવગણો અને સીધા વિભાગ પર જાઓ Google Kubernetes Engine (GKE) પર Istio ઇન્સ્ટોલ કરી રહ્યું છે અથવા એક્સ્ટેંશન ઇન્સ્ટોલ કરી રહ્યું છે GKE પર Istio.

આ એક પગલું-દર-પગલાની માર્ગદર્શિકા છે જ્યાં અમે તમને એક ઉદાહરણ દ્વારા આ તકનીકોની મૂળભૂત સમજ આપવા માટે સ્રોત કોડથી GKE કન્ટેનર સુધીની સમગ્ર પ્રક્રિયામાંથી પસાર થઈશું. તમે એ પણ જોશો કે Istio કેવી રીતે આ ટેક્નોલોજીની શક્તિનો લાભ લે છે. આ ધારે છે કે તમે કન્ટેનર, કુબરનેટ્સ, સર્વિસ મેશ અથવા ઇસ્ટિઓ વિશે કંઈપણ જાણતા નથી.

કાર્યો

આ ટ્યુટોરીયલમાં, તમે નીચેના કાર્યો પૂર્ણ કરશો:

1. બહુવિધ સેવાઓ સાથે એક સરળ હેલો વર્લ્ડ એપ્લિકેશન શીખવી.
2. સોર્સ કોડથી એપ્લિકેશન ચલાવો.
3. કન્ટેનરમાં એપ્લિકેશનનું પેકેજિંગ.
4. કુબરનેટ્સ ક્લસ્ટર બનાવવું.
5. કન્ટેનરને ક્લસ્ટરમાં જમાવવું.

તમે શરૂ કરો તે પહેલાં

Kubernetes Engine API ને સક્ષમ કરવા માટે સૂચનાઓને અનુસરો:

1. પર જાઓ કુબરનેટ્સ એન્જિન પૃષ્ઠ Google Cloud Platform કન્સોલમાં.
2. પ્રોજેક્ટ બનાવો અથવા પસંદ કરો.
3. API અને સંબંધિત સેવાઓ સક્ષમ ન થાય ત્યાં સુધી રાહ જુઓ. આમાં થોડો સમય લાગી શકે છે.
4. ખાતરી કરો કે તમારા Google Cloud Platform પ્રોજેક્ટ માટે બિલિંગ સેટ કરેલ છે. બિલિંગ કેવી રીતે સક્ષમ કરવું તે જાણો.

આ ટ્યુટોરીયલમાં, તમે ક્લાઉડ શેલનો ઉપયોગ કરી શકો છો, જે વર્ચ્યુઅલ મશીન તૈયાર કરે છે Google કોમ્પ્યુટ એન્જિનમાં g1-સ્મોલ ડેબિયન-આધારિત Linux, અથવા Linux અથવા macOS કમ્પ્યુટર સાથે.

વિકલ્પ A: ક્લાઉડ શેલનો ઉપયોગ કરવો

ક્લાઉડ શેલનો ઉપયોગ કરવાના ફાયદા:

• Python 2 અને Python 3 વિકાસ વાતાવરણ (સહિત વર્ચ્યુએલેનવ) સંપૂર્ણપણે રૂપરેખાંકિત થયેલ છે.
• કમાન્ડ લાઇન ટૂલ્સ gCloud, ગોદી, ગિટ и kubectl, જેનો આપણે ઉપયોગ કરીશું તે પહેલાથી જ ઇન્સ્ટોલ કરેલ છે.
• તમારી પાસે પસંદ કરવા માટે ઘણા છે ટેક્સ્ટ સંપાદકો:
  1. કોડ એડિટર, જે ક્લાઉડ શેલ વિન્ડોની ટોચ પર સંપાદન આયકન સાથે ખુલે છે.
  2. Emacs, Vim અથવા Nano, જે ક્લાઉડ શેલમાં કમાન્ડ લાઇનમાંથી ખુલે છે.

વાપરવા માટે મેઘ શેલ:

1. GCP કન્સોલ પર જાઓ.
2. પ્રેસ મેઘ શેલ સક્રિય કરો (ક્લાઉડ શેલ સક્રિય કરો) GCP કન્સોલ વિન્ડોની ટોચ પર.

નીચેના ભાગમાં GCP કન્સોલ કમાન્ડ લાઇન સાથેનું ક્લાઉડ શેલ સત્ર નવી વિન્ડોમાં ખુલશે.

વિકલ્પ B: કમાન્ડ લાઇન ટૂલ્સનો સ્થાનિક રીતે ઉપયોગ કરવો

જો તમે Linux અથવા macOS ચલાવતા કમ્પ્યુટર પર કામ કરશો, તો તમારે નીચેના ઘટકોને ગોઠવવા અને ઇન્સ્ટોલ કરવાની જરૂર પડશે:

1. કસ્ટમાઇઝ કરો Python 3 અને Python 2 વિકાસ પર્યાવરણ.

2. Cloud SDK ઇન્સ્ટોલ કરો આદેશ વાક્ય સાધન સાથે gCloud.

3. સેટ કરો kubectl - સાથે કામ કરવા માટે કમાન્ડ લાઇન ટૂલ ક્યુબર્નેટિસ.

   gcloud components install kubectl

4. સેટ કરો ડોકર કોમ્યુનિટી એડિશન (CE). તમે કમાન્ડ લાઇન ટૂલનો ઉપયોગ કરશો ગોદીનમૂના એપ્લિકેશન માટે કન્ટેનર છબીઓ બનાવવા માટે.

5. ટૂલ ઇન્સ્ટોલ કરો ગિટ સંસ્કરણ નિયંત્રણGitHub માંથી નમૂના એપ્લિકેશન મેળવવા માટે.

નમૂના કોડ ડાઉનલોડ કરો

1. સ્ત્રોત કોડ ડાઉનલોડ કરો હેલોસર્વર:

   git clone https://github.com/GoogleCloudPlatform/istio-samples

2. ઉદાહરણ કોડ ડિરેક્ટરી પર જાઓ:

   cd istio-samples/sample-apps/helloserver

બહુવિધ સેવાઓ સાથે એપ્લિકેશનની શોધખોળ

નમૂના એપ્લિકેશન પાયથોનમાં લખાયેલ છે અને તેમાં બે ઘટકોનો સમાવેશ થાય છે જે ઉપયોગ કરીને ક્રિયાપ્રતિક્રિયા કરે છે REST:

• સર્વર: એક અંતિમ બિંદુ સાથે સરળ સર્વર મેળવો, /, જે કન્સોલ પર "hello world" પ્રિન્ટ કરે છે.
• લોડજન: સ્ક્રિપ્ટ જે ટ્રાફિક મોકલે છે સર્વર, પ્રતિ સેકન્ડ વિનંતીઓની રૂપરેખાંકિત સંખ્યા સાથે.

સ્રોત કોડમાંથી એપ્લિકેશન ચલાવવી

નમૂના એપ્લિકેશનનું અન્વેષણ કરવા માટે, તેને ક્લાઉડ શેલમાં અથવા તમારા કમ્પ્યુટર પર ચલાવો.
1) સૂચિમાં istio-samples/sample-apps/helloserver દોડવું સર્વર:

python3 server/server.py

શરૂઆતમાં સર્વર નીચે દર્શાવેલ છે:

INFO:root:Starting server...

2) વિનંતીઓ મોકલવા માટે બીજી ટર્મિનલ વિન્ડો ખોલો સર્વર. જો તમે ક્લાઉડ શેલનો ઉપયોગ કરી રહ્યાં છો, તો બીજું સત્ર ખોલવા માટે ઍડ આઇકન પર ક્લિક કરો.
3) ને વિનંતી મોકલો સર્વર:

curl http://localhost:8080

સર્વર જવાબો:

Hello World!

4) તમે જે નિર્દેશિકામાંથી નમૂના કોડ ડાઉનલોડ કર્યો છે, તે નિર્દેશિકા પર જાઓ જેમાં શામેલ છે લોડજન:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/loadgen

5) નીચેના પર્યાવરણ ચલો બનાવો:

export SERVER_ADDR=http://localhost:8080
export REQUESTS_PER_SECOND=5

6) લોંચ કરો વર્ચ્યુએલેનવ:

virtualenv --python python3 env

7) વર્ચ્યુઅલ પર્યાવરણને સક્રિય કરો:

source env/bin/activate

8) માટે જરૂરીયાતો સેટ કરો લોડજન:

pip3 install -r requirements.txt

9) લોંચ કરો લોડજન:

python3 loadgen.py

શરૂઆતમાં લોડજન નીચેના સંદેશ જેવું કંઈક દર્શાવે છે:

Starting loadgen: 2019-05-20 10:44:12.448415
5 request(s) complete to http://localhost:8080

અન્ય ટર્મિનલ વિન્ડોમાં સર્વર કન્સોલ પર નીચેના સંદેશાઓ આઉટપુટ કરે છે:

127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /
Headers:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

નેટવર્કિંગ પરિપ્રેક્ષ્યમાં, સમગ્ર એપ્લિકેશન એક જ હોસ્ટ (સ્થાનિક કમ્પ્યુટર અથવા ક્લાઉડ શેલ વર્ચ્યુઅલ મશીન) પર ચાલે છે. તેથી તમે ઉપયોગ કરી શકો છો લોકલહોસ્ટને વિનંતીઓ મોકલવા માટે સર્વર.
10) રોકવા માટે લોડજન и સર્વર, દાખલ કરો Ctrl-c દરેક ટર્મિનલ વિન્ડોમાં.
11) ટર્મિનલ વિન્ડોમાં લોડજન વર્ચ્યુઅલ પર્યાવરણને નિષ્ક્રિય કરો:

deactivate

કન્ટેનરમાં એપ્લિકેશનનું પેકેજિંગ

GKE પર એપ્લિકેશન ચલાવવા માટે, તમારે નમૂના એપ્લિકેશન - પેકેજ કરવાની જરૂર છે સર્વર и લોડજન - અંતે કન્ટેનર. કન્ટેનર એ એપ્લિકેશનને તેના પર્યાવરણથી અલગ કરવા માટે પેકેજ કરવાની રીત છે.

એપ્લિકેશનને કન્ટેનરમાં પેક કરવા માટે, તમારે જરૂર છે ડોકરફાઇલ. ડોકરફાઇલ એ એક ટેક્સ્ટ ફાઇલ છે જે એપ્લીકેશનના સોર્સ કોડ અને તેની અવલંબનને બનાવવા માટેના આદેશોને વ્યાખ્યાયિત કરે છે ડોકર છબી. એકવાર બિલ્ટ થઈ ગયા પછી, તમે ઇમેજને કન્ટેનર રજિસ્ટ્રીમાં અપલોડ કરો જેમ કે ડોકર હબ અથવા કન્ટેનર રજિસ્ટ્રી.

ઉદાહરણ પહેલેથી જ છે ડોકરફાઇલ માટે સર્વર и લોડજન છબીઓ એકત્રિત કરવા માટેના તમામ જરૂરી આદેશો સાથે. નીચે - ડોકરફાઇલ માટે સર્વર:

FROM python:3-slim as base
FROM base as builder
RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        g++ 
    && rm -rf /var/lib/apt/lists/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        wget

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Add the application
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

• ટીમ python માંથી:3-બેઝ તરીકે પાતળો ડોકરને નવીનતમ ઉપયોગ કરવા કહે છે પાયથોન 3 છબી આધાર તરીકે.
• ટીમ કોપી. . વર્તમાન કાર્યકારી નિર્દેશિકામાં સ્રોત ફાઇલોની નકલ કરે છે (ફક્ત અમારા કિસ્સામાં server.py) કન્ટેનરની ફાઇલ સિસ્ટમમાં.
• પ્રવેશ બિંદુ કન્ટેનર શરૂ કરવા માટે વપરાયેલ આદેશને વ્યાખ્યાયિત કરે છે. અમારા કિસ્સામાં, આ આદેશ લગભગ તમે ચલાવવા માટે ઉપયોગમાં લેવાતા સમાન છે server.py સ્ત્રોત કોડમાંથી.
• ટીમ એક્સપોઝ તે દર્શાવે છે સર્વર પોર્ટ દ્વારા ડેટાની રાહ જુએ છે 8080. આ ટીમ નથી બંદરો પૂરા પાડે છે. આ અમુક પ્રકારના દસ્તાવેજો છે જે પોર્ટ ખોલવા માટે જરૂરી છે 8080 કન્ટેનર શરૂ કરતી વખતે.

તમારી અરજીને કન્ટેનરાઇઝ કરવાની તૈયારી કરી રહ્યાં છીએ

1) નીચેના પર્યાવરણ ચલો સેટ કરો. બદલો PROJECT_ID તમારા GCP પ્રોજેક્ટ ID પર.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

મૂલ્યોનો ઉપયોગ કરીને PROJECT_ID и GCR_REPO તમે ડોકર ઇમેજને ટેગ કરો છો જ્યારે તમે તેને બિલ્ડ કરો છો અને તેને ખાનગી કન્ટેનર રજિસ્ટ્રીમાં દબાણ કરો છો.

2) કમાન્ડ લાઇન ટૂલ માટે ડિફોલ્ટ GCP પ્રોજેક્ટ સેટ કરો gCloud.

gcloud config set project $PROJECT_ID

3) કમાન્ડ લાઇન ટૂલ માટે ડિફોલ્ટ ઝોન સેટ કરો gCloud.

gcloud config set compute/zone us-central1-b

4) ખાતરી કરો કે GCP પ્રોજેક્ટમાં કન્ટેનર રજિસ્ટ્રી સેવા સક્ષમ છે.

gcloud services enable containerregistry.googleapis.com

કન્ટેનરાઇઝેશન સર્વર

1. ડિરેક્ટરી પર જાઓ જ્યાં ઉદાહરણ સ્થિત છે સર્વર:

   cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

2. નો ઉપયોગ કરીને ઇમેજ એસેમ્બલ કરો ડોકરફાઇલ અને તમે અગાઉ વ્યાખ્યાયિત કરેલ પર્યાવરણ ચલ:

   docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .

પેરામીટર -t ડોકર ટેગ રજૂ કરે છે. કન્ટેનર જમાવતી વખતે તમે ઉપયોગ કરો છો તે છબીનું આ નામ છે.

1. કન્ટેનર રજિસ્ટ્રી પર છબી અપલોડ કરો:

   docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

લોડજનનું કન્ટેનરાઇઝેશન

1) ડિરેક્ટરી પર જાઓ જ્યાં ઉદાહરણ સ્થિત છે લોડજન:

cd ../loadgen

2) છબી એકત્રિત કરો:

docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .

3) કન્ટેનર રજિસ્ટ્રી પર છબી અપલોડ કરો:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1

છબીઓની સૂચિ જુઓ

રીપોઝીટરીમાં છબીઓની સૂચિની સમીક્ષા કરો અને ચકાસો કે છબીઓ અપલોડ કરવામાં આવી છે:

gcloud container images list --repository gcr.io/$PROJECT_ID/preparing-istio

આદેશ નવી અપલોડ કરેલી છબીઓના નામ દર્શાવે છે:

NAME
gcr.io/PROJECT_ID/preparing-istio/helloserver
gcr.io/PROJECT_ID/preparing-istio/loadgen

GKE ક્લસ્ટર બનાવી રહ્યું છે.

આ કન્ટેનર ક્લાઉડ શેલ વર્ચ્યુઅલ મશીન પર અથવા આદેશ સાથે કમ્પ્યુટર પર ચલાવી શકાય છે ડોકર રન. પરંતુ ઉત્પાદન વાતાવરણમાં, તમારે કન્ટેનરને કેન્દ્રિય રીતે ઓર્કેસ્ટ્રેટ કરવાની રીતની જરૂર છે. ઉદાહરણ તરીકે, તમારે એક એવી સિસ્ટમની જરૂર છે જે ખાતરી કરે કે કન્ટેનર હંમેશા ચાલતું હોય અને જો ટ્રાફિક વધે તો તમારે વધારાના કન્ટેનર દાખલાઓને માપવા અને સ્પિન અપ કરવાની રીતની જરૂર છે.

કન્ટેનરાઇઝ્ડ એપ્લિકેશનો ચલાવવા માટે તમે ઉપયોગ કરી શકો છો જી.કે.ઇ.. GKE એ કન્ટેનર ઓર્કેસ્ટ્રેશન પ્લેટફોર્મ છે જે વર્ચ્યુઅલ મશીનોને ક્લસ્ટરમાં એકીકૃત કરે છે. દરેક વર્ચ્યુઅલ મશીનને નોડ કહેવામાં આવે છે. GKE ક્લસ્ટરો ઓપન સોર્સ કુબરનેટ્સ ક્લસ્ટર મેનેજમેન્ટ સિસ્ટમ પર આધારિત છે. કુબરનેટ્સ ક્લસ્ટર સાથે ક્રિયાપ્રતિક્રિયા કરવા માટેની પદ્ધતિઓ પ્રદાન કરે છે.

GKE ક્લસ્ટર બનાવવું:

1) ક્લસ્ટર બનાવો:

gcloud container clusters create istioready 
  --cluster-version latest 
  --machine-type=n1-standard-2 
  --num-nodes 4

ટીમ gCloud તમે ઉલ્લેખિત કરેલ GCP પ્રોજેક્ટ અને ડિફોલ્ટ ઝોનમાં એક istioready ક્લસ્ટર બનાવે છે. Istio ચલાવવા માટે, અમે ઓછામાં ઓછા 4 નોડ્સ અને વર્ચ્યુઅલ મશીન રાખવાની ભલામણ કરીએ છીએ n1-ધોરણ-2.

ટીમ થોડીવારમાં ક્લસ્ટર બનાવે છે. જ્યારે ક્લસ્ટર તૈયાર થાય છે, ત્યારે આદેશ કંઈક આના જેવું આઉટપુટ કરે છે Сообщение.

2) કમાન્ડ લાઇન ટૂલમાં ઓળખપત્રો પ્રદાન કરો kubectlક્લસ્ટરનું સંચાલન કરવા માટે તેનો ઉપયોગ કરવા માટે:

gcloud container clusters get-credentials istioready

3) હવે તમે કુબરનેટ્સ સાથે મારફતે વાતચીત કરી શકો છો kubectl. ઉદાહરણ તરીકે, નીચેનો આદેશ નોડ્સની સ્થિતિ શોધી શકે છે:

kubectl get nodes

આદેશ નોડ્સની સૂચિ બનાવે છે:

NAME                                       STATUS   ROLES    AGE    VERSION
gke-istoready-default-pool-dbeb23dc-1vg0   Ready    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Ready    <none>   100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Ready    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Ready    <none>   99s    v1.13.6-gke.13

કુબરનેટ્સ કી ખ્યાલો

ડાયાગ્રામ GKE પર એપ્લિકેશન બતાવે છે:

તમે GKE માં કન્ટેનર જમાવતા પહેલા, કુબરનેટ્સના મુખ્ય ખ્યાલો જાણો. જો તમે વધુ જાણવા માંગતા હોવ તો ખૂબ જ અંતમાં લિંક્સ છે.

• ગાંઠો અને ક્લસ્ટરો. GKE માં, નોડ એ વર્ચ્યુઅલ મશીન છે. અન્ય Kubernetes પ્લેટફોર્મ પર, નોડ કમ્પ્યુટર અથવા વર્ચ્યુઅલ મશીન હોઈ શકે છે. ક્લસ્ટર એ નોડ્સનો સંગ્રહ છે જેને એક એકમ ગણી શકાય જ્યાં તમે કન્ટેનરાઇઝ્ડ એપ્લિકેશન જમાવશો.
• શીંગો. કુબરનેટ્સમાં, કન્ટેનર શીંગોમાં ચાલે છે. કુબરનેટીસમાં પોડ એ અવિભાજ્ય એકમ છે. પોડ એક અથવા વધુ કન્ટેનર ધરાવે છે. તમે સર્વર કન્ટેનર જમાવશો અને લોડજન અલગ શીંગો માં. જ્યારે પોડમાં ઘણા કન્ટેનર હોય છે (ઉદાહરણ તરીકે, એપ્લિકેશન સર્વર અને પ્રોક્સી સર્વર), કન્ટેનર એક જ એન્ટિટી તરીકે સંચાલિત થાય છે અને પોડ સંસાધનો શેર કરે છે.
• જમાવટ. કુબરનેટ્સમાં, જમાવટ એ એક પદાર્થ છે જે સમાન પોડ્સનો સંગ્રહ છે. ડિપ્લોયમેન્ટ ક્લસ્ટર નોડ્સમાં વિતરિત પોડ્સની બહુવિધ પ્રતિકૃતિઓ લોન્ચ કરે છે. ડિપ્લોયમેન્ટ એ પોડ્સને આપમેળે બદલી નાખે છે જે નિષ્ફળ ગઈ હોય અથવા પ્રતિભાવવિહીન હોય.
• કુબરનેટ્સ સેવા. GKE માં એપ્લિકેશન કોડ ચલાવતી વખતે, વચ્ચેનું જોડાણ લોડજન и સર્વર. જ્યારે તમે ક્લાઉડ શેલ વર્ચ્યુઅલ મશીન અથવા ડેસ્કટોપ પર સેવાઓ શરૂ કરી, ત્યારે તમે વિનંતીઓ મોકલી સર્વર પર લોકલહોસ્ટ: 8080. એકવાર GKE માં જમાવવામાં આવ્યા પછી, પોડ્સ ઉપલબ્ધ નોડ્સ પર એક્ઝિક્યુટ કરવામાં આવે છે. મૂળભૂત રીતે, પોડ કયા નોડ પર ચાલી રહ્યું છે તેના પર તમારું કોઈ નિયંત્રણ નથી, તેથી તમે શીંગો કોઈ કાયમી IP સરનામાં નથી.
  માટે IP સરનામું મેળવવા માટે સર્વર, તમારે પોડ્સની ટોચ પર નેટવર્ક એબ્સ્ટ્રેક્શન વ્યાખ્યાયિત કરવાની જરૂર છે. તે શું છે કુબરનેટ્સ સેવા. કુબરનેટ્સ સેવા પોડ્સના સમૂહ માટે સતત અંતિમ બિંદુ પ્રદાન કરે છે. ત્યાં થોડા છે સેવાઓના પ્રકારો. સર્વર ઉપયોગ કરે છે લોડબેલેન્સર, જે સંપર્ક કરવા માટે બાહ્ય IP સરનામું પ્રદાન કરે છે સર્વર ક્લસ્ટરની બહારથી.
  કુબરનેટ્સમાં બિલ્ટ-ઇન DNS સિસ્ટમ પણ છે જે DNS નામો સોંપે છે (ઉદાહરણ તરીકે, helloserver.default.cluster.local) સેવાઓ. આનો આભાર, ક્લસ્ટરની અંદરની શીંગો કાયમી સરનામા પર ક્લસ્ટરમાં અન્ય શીંગો સાથે વાતચીત કરે છે. DNS નામનો ક્લસ્ટરની બહાર ઉપયોગ કરી શકાતો નથી, જેમ કે ક્લાઉડ શેલમાં અથવા કમ્પ્યુટર પર.

કુબરનેટ્સ મેનીફેસ્ટ કરે છે

જ્યારે તમે સ્ત્રોતમાંથી એપ્લિકેશન ચલાવો છો, ત્યારે તમે આવશ્યક આદેશનો ઉપયોગ કર્યો હતો python3

server.py

આવશ્યક ક્રિયાપદ સૂચવે છે: "આ કરો."

કુબરનેટ્સ ઉપયોગ કરે છે ઘોષણાત્મક મોડેલ. આનો અર્થ એ છે કે અમે કુબરનેટ્સને બરાબર શું કરવું તે કહી રહ્યા નથી, પરંતુ ઇચ્છિત સ્થિતિનું વર્ણન કરી રહ્યા છીએ. ઉદાહરણ તરીકે, સિસ્ટમની વાસ્તવિક સ્થિતિ ઇચ્છિત સ્થિતિ સાથે મેળ ખાય છે તેની ખાતરી કરવા માટે કુબરનેટ્સ જરૂર મુજબ શીંગો શરૂ કરે છે અને બંધ કરે છે.

તમે મેનિફેસ્ટ અથવા ફાઇલોમાં ઇચ્છિત સ્થિતિ સૂચવો છો YAML. YAML ફાઇલમાં એક અથવા વધુ કુબરનેટ્સ ઑબ્જેક્ટ માટે વિશિષ્ટતાઓ શામેલ છે.

ઉદાહરણમાં માટે YAML ફાઇલ છે સર્વર и લોડજન. દરેક YAML ફાઇલ ડિપ્લોયમેન્ટ ઑબ્જેક્ટ અને કુબરનેટ્સ સેવાની ઇચ્છિત સ્થિતિનો ઉલ્લેખ કરે છે.

server.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  selector:
    matchLabels:
      app: helloserver
  replicas: 1
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always

• પ્રકારની ઑબ્જેક્ટનો પ્રકાર સૂચવે છે.
• metadata.name જમાવટનું નામ સ્પષ્ટ કરે છે.
• પ્રથમ ક્ષેત્ર સ્પેક ઇચ્છિત સ્થિતિનું વર્ણન સમાવે છે.
• spec.replicas શીંગોની ઇચ્છિત સંખ્યા દર્શાવે છે.
• વિભાગ spec.template પોડ ટેમ્પલેટ વ્યાખ્યાયિત કરે છે. પોડ સ્પષ્ટીકરણમાં એક ક્ષેત્ર છે છબી, જે ઇમેજનું નામ સ્પષ્ટ કરે છે જેને કન્ટેનર રજિસ્ટ્રીમાંથી કાઢવાની જરૂર છે.

સેવા નીચે પ્રમાણે વ્યાખ્યાયિત થયેલ છે:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  type: LoadBalancer
  selector:
    app: helloserver
  ports:
  - name: http
    port: 80
    targetPort: 8080

• લોડબેલેન્સર: ક્લાયન્ટ લોડ બેલેન્સરના IP એડ્રેસ પર વિનંતીઓ મોકલે છે, જે સતત IP એડ્રેસ ધરાવે છે અને ક્લસ્ટરની બહારથી ઍક્સેસ કરી શકાય છે.
• લક્ષ્યપોર્ટ: જેમ તમને યાદ છે, ટીમ 8080 એક્સપોઝ કરો в ડોકરફાઇલ બંદરો આપ્યા નથી. તમે પોર્ટ પ્રદાન કરો 8080જેથી તમે કન્ટેનરનો સંપર્ક કરી શકો સર્વર ક્લસ્ટરની બહાર. અમારા કિસ્સામાં hellosvc.default.cluster.local:80 (ટુકુ નામ: હેલોસવીસી) પોર્ટને અનુલક્ષે છે 8080 પોડ IP સરનામાં હેલોસર્વર.
• પોર્ટ: આ તે પોર્ટ નંબર છે જ્યાં ક્લસ્ટરની અન્ય સેવાઓ વિનંતીઓ મોકલશે.

loadgen.yaml

માટે ડિપ્લોયમેન્ટ ઑબ્જેક્ટ loadgen.yaml જેમ દેખાય server.yaml. તફાવત એ છે કે જમાવટ ઑબ્જેક્ટમાં એક વિભાગ છે આશરે. તે પર્યાવરણ ચલોને વ્યાખ્યાયિત કરે છે જે જરૂરી છે લોડજન અને સ્ત્રોતમાંથી એપ્લિકેશન ચલાવતી વખતે તમે જે ઇન્સ્ટોલ કર્યું છે.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  selector:
    matchLabels:
      app: loadgenerator
  replicas: 1
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        env:
        - name: SERVER_ADDR
          value: "http://hellosvc:80/"
        - name: REQUESTS_PER_SECOND
          value: "10"
        resources:
          requests:
            cpu: 300m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi

એકવાર લોડજન ક્ષેત્ર માટે, આવનારી વિનંતીઓ સ્વીકારતું નથી પ્રકાર સંકેત ક્લસ્ટરઆઈપી. આ પ્રકાર સતત IP સરનામું પ્રદાન કરે છે જેનો ક્લસ્ટરમાં સેવાઓ ઉપયોગ કરી શકે છે, પરંતુ આ IP સરનામું બાહ્ય ક્લાયન્ટ્સ માટે ખુલ્લું નથી.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  type: ClusterIP
  selector:
    app: loadgenerator
  ports:
  - name: http
    port: 80
    targetPort: 8080

GKE માં કન્ટેનર જમાવવું

1) ડિરેક્ટરી પર જાઓ જ્યાં ઉદાહરણ સ્થિત છે સર્વર:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

2) ખોલો server.yaml ટેક્સ્ટ એડિટરમાં.
3) ક્ષેત્રમાં નામ બદલો છબી તમારી ડોકર ઇમેજના નામ પર.

image: gcr.io/PROJECT_ID/preparing-istio/helloserver:v0.0.1

બદલો PROJECT_ID તમારા GCP પ્રોજેક્ટ ID પર.
4) સાચવો અને બંધ કરો server.yaml.
5) YAML ફાઇલને કુબરનેટ્સ પર જમાવો:

kubectl apply -f server.yaml

સફળ સમાપ્તિ પર, આદેશ નીચેનો કોડ બનાવે છે:

deployment.apps/helloserver created
service/hellosvc created

6) ડિરેક્ટરી પર જાઓ જ્યાં લોડજન:

cd ../loadgen

7) ખોલો loadgen.yaml ટેક્સ્ટ એડિટરમાં.
8) ક્ષેત્રમાં નામ બદલો છબી તમારી ડોકર ઇમેજના નામ પર.

image: gcr.io/PROJECT_ID/preparing-istio/loadgenv0.0.1

બદલો PROJECT_ID તમારા GCP પ્રોજેક્ટ ID પર.
9) સાચવો અને બંધ કરો loadgen.yaml, ટેક્સ્ટ એડિટર બંધ કરો.
10) YAML ફાઇલને કુબરનેટ્સ પર જમાવો:

kubectl apply -f loadgen.yaml

સફળ સમાપ્તિ પર, આદેશ નીચેનો કોડ બનાવે છે:

deployment.apps/loadgenerator created
service/loadgensvc created

11) શીંગોની સ્થિતિ તપાસો:

kubectl get pods

આદેશ સ્થિતિ બતાવે છે:

NAME                             READY   STATUS    RESTARTS   AGE
helloserver-69b9576d96-mwtcj     1/1     Running   0          58s
loadgenerator-774dbc46fb-gpbrz   1/1     Running   0          57s

12) પોડમાંથી એપ્લિકેશન લોગ બહાર કાઢો લોડજન. બદલો POD_ID અગાઉના જવાબમાંથી ઓળખકર્તાને.

kubectl logs loadgenerator-POD_ID

13) બાહ્ય IP સરનામાઓ મેળવો હેલોસવીસી:

kubectl get service

આદેશ પ્રતિસાદ આના જેવો દેખાય છે:

NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
hellosvc     LoadBalancer   10.81.15.158   192.0.2.1       80:31127/TCP   33m
kubernetes   ClusterIP      10.81.0.1      <none>          443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s

14) ને વિનંતી મોકલો હેલોસવીસી: બદલો EXTERNAL_IP બાહ્ય IP સરનામા પર હેલોસવીસી.

curl http://EXTERNAL_IP

ચાલો Istio પર લઈએ

તમારી પાસે પહેલેથી જ GKE પર એક એપ્લિકેશન જમાવાયેલી છે. લોડજન કુબરનેટ્સ DNS નો ઉપયોગ કરી શકે છે (hellosvc:80) ને વિનંતીઓ મોકલવા માટે સર્વરઅને તમે વિનંતીઓ મોકલી શકો છો સર્વર બાહ્ય IP સરનામા દ્વારા. કુબરનેટ્સમાં ઘણી સુવિધાઓ હોવા છતાં, સેવાઓ વિશે કેટલીક માહિતી ખૂટે છે:

• સેવાઓ કેવી રીતે ક્રિયાપ્રતિક્રિયા કરે છે? સેવાઓ વચ્ચેના સંબંધો શું છે? સેવાઓ વચ્ચે ટ્રાફિક કેવી રીતે વહે છે? શું તમે તેનાથી વાકેફ છો લોડજન ને વિનંતીઓ મોકલે છે સર્વર, પરંતુ કલ્પના કરો કે તમે એપ્લિકેશન વિશે કંઈપણ જાણતા નથી. આ પ્રશ્નોના જવાબ આપવા માટે, ચાલો GKE માં ચાલી રહેલા પોડ્સની સૂચિ જોઈએ.
• મેટ્રિક્સ. કેટલુ લાંબુ સર્વર આવનારી વિનંતીનો જવાબ આપે છે? સર્વર દ્વારા પ્રતિ સેકન્ડ કેટલી વિનંતીઓ પ્રાપ્ત થાય છે? શું તે ભૂલ સંદેશાઓ આપે છે?
• સુરક્ષા માહિતી. વચ્ચે ટ્રાફિક લોડજન и સર્વર માત્ર પસાર થાય છે HTTP અથવા દ્વારા mTLS?

Istio આ બધા પ્રશ્નોના જવાબ આપે છે. આ કરવા માટે, Istio સાઇડકાર પ્રોક્સી મૂકે છે દૂત દરેક પોડ માં. એન્વોય પ્રોક્સી એપ્લીકેશન કન્ટેનરમાં આવતા અને જતા તમામ ટ્રાફિકને અટકાવે છે. તેનો અર્થ એ છે કે સર્વર и લોડજન સાઇડકાર પ્રોક્સી એન્વોય દ્વારા પ્રાપ્ત કરો, અને તમામ ટ્રાફિક લોડજન к સર્વર દૂત પ્રોક્સીમાંથી પસાર થાય છે.

દૂત પ્રોક્સીઓ વચ્ચેના જોડાણો સેવા મેશ બનાવે છે. સર્વિસ મેશ આર્કિટેક્ચર કુબરનેટ્સની ટોચ પર નિયંત્રણનું સ્તર પૂરું પાડે છે.

એન્વોય પ્રોક્સીઓ તેમના પોતાના કન્ટેનરમાં ચાલતી હોવાથી, એપ્લિકેશન કોડમાં લગભગ કોઈ ફેરફાર કર્યા વિના Istio GKE ક્લસ્ટરની ટોચ પર ઇન્સ્ટોલ કરી શકાય છે. પરંતુ તમે તમારી એપ્લિકેશનને Istio દ્વારા સંચાલિત કરવા માટે તૈયાર કરવા માટે થોડું કામ કર્યું છે:

• બધા કન્ટેનર માટે સેવાઓ. જમાવટ માટે સર્વર и લોડજન કુબરનેટ્સ સેવા સાથે જોડાયેલ છે. સમ લોડજન, જે આવનારી વિનંતીઓ પ્રાપ્ત કરતી નથી, ત્યાં એક સેવા છે.
• સેવાઓમાં બંદરોના નામ હોવા આવશ્યક છે. જો કે GKE માં સર્વિસ પોર્ટનું નામ વગર છોડી શકાય છે, Istio માટે તમારે સ્પષ્ટ કરવું જરૂરી છે પોર્ટ નામ તેના પ્રોટોકોલ અનુસાર. YAML ફાઇલમાં માટે પોર્ટ સર્વર કહેવાય છે httpકારણ કે સર્વર પ્રોટોકોલ વાપરે છે HTTP. જો સેવા વપરાયેલ gRPC, તમે પોર્ટનું નામ આપશો grpc.
• જમાવટ ધ્વજાંકિત છે. તેથી, તમે Istio ની ટ્રાફિક મેનેજમેન્ટ સુવિધાઓનો ઉપયોગ કરી શકો છો, જેમ કે સમાન સેવાના સંસ્કરણો વચ્ચે ટ્રાફિકનું વિભાજન.

સ્થાપન

Istio ઇન્સ્ટોલ કરવાની બે રીત છે. કરી શકે છે GKE એક્સ્ટેંશન પર Istio સક્ષમ કરો અથવા Istio નું ઓપન સોર્સ વર્ઝન ઇન્સ્ટોલ કરો ક્લસ્ટર પર. GKE પર Istio સાથે, તમે સમગ્ર GKE ક્લસ્ટર જીવનચક્ર દરમ્યાન Istio ઇન્સ્ટોલેશન અને અપગ્રેડને સરળતાથી મેનેજ કરી શકો છો. જો તમને Istio નું નવીનતમ સંસ્કરણ અથવા તમારા Istio નિયંત્રણ પેનલ ગોઠવણી પર વધુ નિયંત્રણ જોઈએ છે, તો GKE એક્સ્ટેંશન પર Istio ને બદલે ઓપન સોર્સ સંસ્કરણ ઇન્સ્ટોલ કરો. અભિગમ નક્કી કરવા માટે, લેખ વાંચો શું મારે GKE પર Istio ની જરૂર છે?.

એક વિકલ્પ પસંદ કરો, યોગ્ય માર્ગદર્શિકાની સમીક્ષા કરો અને તમારા ક્લસ્ટર પર Istio ઇન્સ્ટોલ કરવા માટેની સૂચનાઓને અનુસરો. જો તમે તમારી નવી જમાવટ કરેલ એપ્લિકેશન સાથે Istio નો ઉપયોગ કરવા માંગતા હો, સાઇડકાર અમલીકરણને સક્ષમ કરો નેમસ્પેસ માટે મૂળભૂત.

ઓકિસ્ક્કક

તમે આ ટ્યુટોરીયલમાં ઉપયોગમાં લીધેલા સંસાધનો માટે તમારા Google Cloud Platform એકાઉન્ટ પર શુલ્ક લેવાનું ટાળવા માટે, એકવાર તમે Istio ઇન્સ્ટોલ કરી લો અને નમૂના એપ્લિકેશન સાથે રમી લો તે પછી કન્ટેનર ક્લસ્ટરને કાઢી નાખો. આ તમામ ક્લસ્ટર સંસાધનો દૂર કરશે, જેમ કે ગણતરીના દાખલાઓ, ડિસ્ક અને નેટવર્ક સંસાધનો.

શું આગામી છે?

• નીચેની તકનીકોનું અન્વેષણ કરો:

  1. Docker
  2. કન્ટેનર
  3. કન્ટેનર રજિસ્ટ્રી
  4. ક્યુબર્નેટિસ
  5. જી.કે.ઇ.
  6. સેવા મેશ
  7. ઇસ્ટિઓ

• નીચેના સાધનોનું અન્વેષણ કરો:

  1. મેઘ SDK
  2. માટે માર્ગદર્શન gCloud
  3. kubectl
  4. ગોદી

• કુબરનેટીસ ખ્યાલો જાણો:

  1. ક્લસ્ટરો
  2. ગાંઠો
  3. શીંગો
  4. સેવાઓ
  5. જમાવટ

સોર્સ: www.habr.com