ഇസ്തിയോയ്‌ക്കായി ഒരു അപേക്ഷ തയ്യാറാക്കുന്നു

വിതരണം ചെയ്ത ആപ്ലിക്കേഷനുകൾ ബന്ധിപ്പിക്കുന്നതിനും സുരക്ഷിതമാക്കുന്നതിനും നിരീക്ഷിക്കുന്നതിനുമുള്ള സൗകര്യപ്രദമായ ഉപകരണമാണ് ഇസ്തിയോ. സോഫ്‌റ്റ്‌വെയർ സ്കെയിലിൽ പ്രവർത്തിപ്പിക്കാനും നിയന്ത്രിക്കാനും ഇസ്തിയോ വിവിധ സാങ്കേതികവിദ്യകൾ ഉപയോഗിക്കുന്നു, പാക്കേജ് ആപ്ലിക്കേഷൻ കോഡിലേക്കുള്ള കണ്ടെയ്‌നറുകളും വിന്യാസത്തിനുള്ള ഡിപൻഡൻസികളും, ആ കണ്ടെയ്‌നറുകൾ നിയന്ത്രിക്കാൻ കുബെർനെറ്റുകളും ഉൾപ്പെടെ. അതിനാൽ, ഇസ്തിയോയിൽ പ്രവർത്തിക്കാൻ, ഈ സാങ്കേതികവിദ്യകളെ അടിസ്ഥാനമാക്കി ഒന്നിലധികം സേവനങ്ങളുള്ള ഒരു ആപ്ലിക്കേഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നിങ്ങൾ അറിഞ്ഞിരിക്കണം ഇല്ലാതെ ഇസ്തിയോ. ഈ ഉപകരണങ്ങളും ആശയങ്ങളും നിങ്ങൾക്ക് ഇതിനകം പരിചിതമാണെങ്കിൽ, ഈ ട്യൂട്ടോറിയൽ ഒഴിവാക്കി നേരിട്ട് വിഭാഗത്തിലേക്ക് പോകുക Google Kubernetes എഞ്ചിനിൽ (GKE) ഇസ്തിയോ ഇൻസ്റ്റാൾ ചെയ്യുന്നു അല്ലെങ്കിൽ ഒരു വിപുലീകരണം ഇൻസ്റ്റാൾ ചെയ്യുന്നു ജികെഇയിൽ ഇസ്തിയോ.

ഇതൊരു ഘട്ടം ഘട്ടമായുള്ള ഗൈഡാണ്, ഇവിടെ ഞങ്ങൾ സോഴ്‌സ് കോഡ് മുതൽ GKE കണ്ടെയ്‌നർ വരെയുള്ള മുഴുവൻ പ്രക്രിയയിലൂടെയും ഒരു ഉദാഹരണത്തിലൂടെ ഈ സാങ്കേതികവിദ്യകളെക്കുറിച്ച് നിങ്ങൾക്ക് അടിസ്ഥാനപരമായ ധാരണ നൽകും. ഈ സാങ്കേതികവിദ്യകളുടെ ശക്തി ഇസ്തിയോ എങ്ങനെ പ്രയോജനപ്പെടുത്തുന്നുവെന്നും നിങ്ങൾ കാണും. കണ്ടെയ്‌നറുകൾ, കുബർനെറ്റുകൾ, സർവീസ് മെഷുകൾ, ഇസ്തിയോ എന്നിവയെക്കുറിച്ച് നിങ്ങൾക്ക് ഒന്നും അറിയില്ലെന്ന് ഇത് അനുമാനിക്കുന്നു.

ചുമതലകൾ

ഈ ട്യൂട്ടോറിയലിൽ, നിങ്ങൾ ഇനിപ്പറയുന്ന ജോലികൾ പൂർത്തിയാക്കും:

1. ഒന്നിലധികം സേവനങ്ങളുള്ള ഒരു ലളിതമായ ഹലോ വേൾഡ് ആപ്ലിക്കേഷൻ പഠിക്കുന്നു.
2. സോഴ്സ് കോഡിൽ നിന്ന് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുക.
3. കണ്ടെയ്നറുകളിൽ ആപ്ലിക്കേഷൻ പാക്കേജിംഗ്.
4. ഒരു കുബർനെറ്റസ് ക്ലസ്റ്റർ സൃഷ്ടിക്കുന്നു.
5. ഒരു ക്ലസ്റ്ററിലേക്ക് കണ്ടെയ്നറുകൾ വിന്യസിക്കുന്നു.

ആരംഭിക്കുന്നതിന് മുമ്പ്

Kubernetes എഞ്ചിൻ API പ്രവർത്തനക്ഷമമാക്കാൻ നിർദ്ദേശങ്ങൾ പാലിക്കുക:

1. ഗൈഡിതെ എന്ന കുബെർനെറ്റസ് എഞ്ചിൻ പേജ് Google ക്ലൗഡ് പ്ലാറ്റ്‌ഫോം കൺസോളിൽ.
2. ഒരു പ്രോജക്റ്റ് സൃഷ്ടിക്കുക അല്ലെങ്കിൽ തിരഞ്ഞെടുക്കുക.
3. API-യും അനുബന്ധ സേവനങ്ങളും പ്രവർത്തനക്ഷമമാക്കുന്നത് വരെ കാത്തിരിക്കുക. ഇതിന് കുറച്ച് മിനിറ്റുകൾ എടുത്തേക്കാം.
4. നിങ്ങളുടെ Google ക്ലൗഡ് പ്ലാറ്റ്‌ഫോം പ്രോജക്റ്റിനായി ബില്ലിംഗ് സജ്ജീകരിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. ബില്ലിംഗ് എങ്ങനെ പ്രവർത്തനക്ഷമമാക്കാമെന്ന് അറിയുക.

ഈ ട്യൂട്ടോറിയലിൽ, നിങ്ങൾക്ക് വെർച്വൽ മെഷീൻ തയ്യാറാക്കുന്ന ക്ലൗഡ് ഷെൽ ഉപയോഗിക്കാം ഗൂഗിൾ കമ്പ്യൂട്ട് എഞ്ചിനിൽ g1-ചെറിയത് ഡെബിയൻ അടിസ്ഥാനമാക്കിയുള്ള ലിനക്സ് അല്ലെങ്കിൽ ഒരു ലിനക്സ് അല്ലെങ്കിൽ മാകോസ് കമ്പ്യൂട്ടർ.

ഓപ്ഷൻ എ: ക്ലൗഡ് ഷെൽ ഉപയോഗിക്കുന്നു

ക്ലൗഡ് ഷെൽ ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനങ്ങൾ:

• പൈത്തൺ 2, പൈത്തൺ 3 വികസന പരിതസ്ഥിതികൾ (ഉൾപ്പെടെ virtualenv) പൂർണ്ണമായും ക്രമീകരിച്ചിരിക്കുന്നു.
• കമാൻഡ് ലൈൻ ടൂളുകൾ gCloud, ഡോക്കർ, ജിറ്റിനെ и കുബെക്ലി, ഞങ്ങൾ ഉപയോഗിക്കുന്നവ ഇതിനകം ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്.
• നിങ്ങൾക്ക് തിരഞ്ഞെടുക്കാൻ നിരവധിയുണ്ട് ടെക്സ്റ്റ് എഡിറ്റർമാർ:
  1. കോഡ് എഡിറ്റർ, ക്ലൗഡ് ഷെൽ വിൻഡോയുടെ മുകളിലുള്ള എഡിറ്റ് ഐക്കൺ ഉപയോഗിച്ച് തുറക്കുന്നു.
  2. ക്ലൗഡ് ഷെല്ലിലെ കമാൻഡ് ലൈനിൽ നിന്ന് തുറക്കുന്ന Emacs, Vim അല്ലെങ്കിൽ Nano.

ഉപയോഗിക്കാൻ ക്ലൗഡ് ഷെൽ:

1. GCP കൺസോളിലേക്ക് പോകുക.
2. ബട്ടൺ ക്ലിക്കുചെയ്യുക ക്ലൗഡ് ഷെൽ സജീവമാക്കുക (ക്ലൗഡ് ഷെൽ സജീവമാക്കുക) GCP കൺസോൾ വിൻഡോയുടെ മുകളിൽ.

താഴത്തെ ഭാഗത്ത് GCP കൺസോൾ ഒരു കമാൻഡ് ലൈൻ ഉള്ള ഒരു ക്ലൗഡ് ഷെൽ സെഷൻ ഒരു പുതിയ വിൻഡോയിൽ തുറക്കും.

ഓപ്ഷൻ ബി: കമാൻഡ് ലൈൻ ടൂളുകൾ പ്രാദേശികമായി ഉപയോഗിക്കുന്നു

Linux അല്ലെങ്കിൽ macOS പ്രവർത്തിക്കുന്ന ഒരു കമ്പ്യൂട്ടറിലാണ് നിങ്ങൾ പ്രവർത്തിക്കുന്നതെങ്കിൽ, നിങ്ങൾ ഇനിപ്പറയുന്ന ഘടകങ്ങൾ കോൺഫിഗർ ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്:

1. ഇഷ്ടാനുസൃതമാക്കുക പൈത്തൺ 3, പൈത്തൺ 2 വികസന പരിസ്ഥിതി.

2. ക്ലൗഡ് SDK ഇൻസ്റ്റാൾ ചെയ്യുക കമാൻഡ് ലൈൻ ടൂൾ ഉപയോഗിച്ച് gCloud.

3. ഇൻസ്റ്റാൾ ചെയ്യുക കുബെക്ലി - പ്രവർത്തിക്കുന്നതിനുള്ള കമാൻഡ് ലൈൻ ഉപകരണം കുബേർനെറ്റ്.

   gcloud components install kubectl

4. ഇൻസ്റ്റാൾ ചെയ്യുക ഡോക്കർ കമ്മ്യൂണിറ്റി പതിപ്പ് (CE). നിങ്ങൾ കമാൻഡ് ലൈൻ ടൂൾ ഉപയോഗിക്കും ഡോക്കർസാമ്പിൾ ആപ്ലിക്കേഷനായി കണ്ടെയ്നർ ഇമേജുകൾ സൃഷ്ടിക്കാൻ.

5. ഉപകരണം ഇൻസ്റ്റാൾ ചെയ്യുക Git പതിപ്പ് നിയന്ത്രണംGitHub-ൽ നിന്ന് സാമ്പിൾ ആപ്ലിക്കേഷൻ ലഭിക്കാൻ.

സാമ്പിൾ കോഡ് ഡൗൺലോഡ് ചെയ്യുക

1. സോഴ്സ് കോഡ് ഡൗൺലോഡ് ചെയ്യുക helloserver:

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

2. ഉദാഹരണ കോഡ് ഡയറക്ടറിയിലേക്ക് പോകുക:

   cd istio-samples/sample-apps/helloserver

ഒന്നിലധികം സേവനങ്ങളുള്ള ഒരു ആപ്ലിക്കേഷൻ പര്യവേക്ഷണം ചെയ്യുന്നു

സാമ്പിൾ ആപ്ലിക്കേഷൻ പൈത്തണിൽ എഴുതിയിരിക്കുന്നു, കൂടാതെ ഇത് ഉപയോഗിച്ച് സംവദിക്കുന്ന രണ്ട് ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു REST:

• സെർവർ: ഒരു അവസാന പോയിൻ്റുള്ള ലളിതമായ സെർവർ നേടുക, /, കൺസോളിലേക്ക് "ഹലോ വേൾഡ്" എന്ന് പ്രിൻ്റ് ചെയ്യുന്നു.
• ലോഡ്ജെൻ: ട്രാഫിക്ക് അയക്കുന്ന സ്ക്രിപ്റ്റ് സെർവർ, ഒരു സെക്കൻഡിൽ ക്രമീകരിക്കാവുന്ന അഭ്യർത്ഥനകളുടെ എണ്ണം.

സോഴ്സ് കോഡിൽ നിന്ന് ഒരു ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നു

സാമ്പിൾ ആപ്ലിക്കേഷൻ പര്യവേക്ഷണം ചെയ്യാൻ, അത് ക്ലൗഡ് ഷെല്ലിലോ നിങ്ങളുടെ കമ്പ്യൂട്ടറിലോ പ്രവർത്തിപ്പിക്കുക.
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:

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-യിൽ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങൾ സാമ്പിൾ ആപ്ലിക്കേഷൻ പാക്കേജ് ചെയ്യേണ്ടതുണ്ട് - സെർവർ и ലോഡ്ജെൻ - ൽ കണ്ടെയ്നറുകൾ. ഒരു ആപ്ലിക്കേഷനെ അതിൻ്റെ പരിതസ്ഥിതിയിൽ നിന്ന് ഒറ്റപ്പെടുത്താൻ പാക്കേജ് ചെയ്യുന്നതിനുള്ള ഒരു മാർഗമാണ് കണ്ടെയ്നർ.

ഒരു ആപ്ലിക്കേഷൻ ഒരു കണ്ടെയ്‌നറിലേക്ക് പാക്കേജുചെയ്യുന്നതിന്, നിങ്ങൾക്ക് ഇത് ആവശ്യമാണ് Dockerfile. Dockerfile ആപ്ലിക്കേഷൻ്റെ സോഴ്സ് കോഡും അതിൻ്റെ ഡിപൻഡൻസികളും നിർമ്മിക്കുന്നതിനുള്ള കമാൻഡുകൾ നിർവചിക്കുന്ന ഒരു ടെക്സ്റ്റ് ഫയലാണ് ഡോക്കർ ചിത്രം. ഒരിക്കൽ നിർമ്മിച്ചുകഴിഞ്ഞാൽ, ഡോക്കർ ഹബ് അല്ലെങ്കിൽ പോലുള്ള ഒരു കണ്ടെയ്‌നർ രജിസ്ട്രിയിലേക്ക് നിങ്ങൾ ചിത്രം അപ്‌ലോഡ് ചെയ്യുന്നു കണ്ടെയ്നർ രജിസ്ട്രി.

ഉദാഹരണം ഇതിനകം ഉണ്ട് Dockerfile വേണ്ടി സെർവർ и ലോഡ്ജെൻ ചിത്രങ്ങൾ ശേഖരിക്കുന്നതിന് ആവശ്യമായ എല്ലാ കമാൻഡുകളും സഹിതം. താഴെ - Dockerfile വേണ്ടി സെർവർ:

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" ]

• ടീം പൈത്തണിൽ നിന്ന്: 3-സ്ലിം അടിസ്ഥാനമായി ഏറ്റവും പുതിയത് ഉപയോഗിക്കാൻ ഡോക്കറിനോട് പറയുന്നു പൈത്തൺ 3 ചിത്രം അടിസ്ഥാനമായി.
• ടീം പകർത്തുക. . നിലവിലെ പ്രവർത്തിക്കുന്ന ഡയറക്ടറിയിലേക്ക് ഉറവിട ഫയലുകൾ പകർത്തുന്നു (ഞങ്ങളുടെ കാര്യത്തിൽ മാത്രം server.py) കണ്ടെയ്നറിൻ്റെ ഫയൽ സിസ്റ്റത്തിലേക്ക്.
• എൻട്രിപോയിന്റ് കണ്ടെയ്നർ ആരംഭിക്കാൻ ഉപയോഗിക്കുന്ന കമാൻഡ് നിർവചിക്കുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ, ഈ കമാൻഡ് നിങ്ങൾ പ്രവർത്തിപ്പിച്ചതിന് സമാനമാണ് server.py സോഴ്സ് കോഡിൽ നിന്ന്.
• ടീം വെളിപ്പെടുത്തുക എന്ന് സൂചിപ്പിക്കുന്നു സെർവർ പോർട്ട് വഴിയുള്ള ഡാറ്റയ്ക്കായി കാത്തിരിക്കുന്നു 8080. ഈ ടീം അല്ല തുറമുഖങ്ങൾ നൽകുന്നു. പോർട്ട് തുറക്കാൻ ആവശ്യമായ ചില ഡോക്യുമെൻ്റേഷനാണിത് 8080 കണ്ടെയ്നർ ആരംഭിക്കുമ്പോൾ.

നിങ്ങളുടെ അപേക്ഷ കണ്ടെയ്‌നറൈസ് ചെയ്യാൻ തയ്യാറെടുക്കുന്നു

1) ഇനിപ്പറയുന്ന പരിസ്ഥിതി വേരിയബിളുകൾ സജ്ജമാക്കുക. മാറ്റിസ്ഥാപിക്കുക PROJECT_ID നിങ്ങളുടെ GCP പ്രോജക്റ്റ് ഐഡിയിലേക്ക്.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നു PROJECT_ID и GCR_REPO നിങ്ങൾ ഡോക്കർ ചിത്രം നിർമ്മിക്കുമ്പോൾ അത് ടാഗ് ചെയ്യുകയും ഒരു സ്വകാര്യ കണ്ടെയ്നർ രജിസ്ട്രിയിലേക്ക് തള്ളുകയും ചെയ്യുന്നു.

2) കമാൻഡ് ലൈൻ ടൂളിനുള്ള ഡിഫോൾട്ട് ജിസിപി പ്രൊജക്റ്റ് സജ്ജമാക്കുക 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. ഉപയോഗിച്ച് ചിത്രം കൂട്ടിച്ചേർക്കുക Dockerfile നിങ്ങൾ നേരത്തെ നിർവചിച്ച പരിസ്ഥിതി വേരിയബിളുകളും:

   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 ക്ലസ്റ്റർ സൃഷ്ടിക്കുന്നു:

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) കമാൻഡ് ലൈൻ ടൂളിൽ ക്രെഡൻഷ്യലുകൾ നൽകുക കുബെക്ലിക്ലസ്റ്റർ നിയന്ത്രിക്കാൻ ഇത് ഉപയോഗിക്കുന്നതിന്:

gcloud container clusters get-credentials istioready

3) ഇപ്പോൾ നിങ്ങൾക്ക് കുബർനെറ്റസുമായി ആശയവിനിമയം നടത്താം കുബെക്ലി. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കമാൻഡിന് നോഡുകളുടെ നില കണ്ടെത്താൻ കഴിയും:

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-യിൽ, ഒരു നോഡ് ഒരു വെർച്വൽ മെഷീനാണ്. മറ്റ് കുബർനെറ്റസ് പ്ലാറ്റ്‌ഫോമുകളിൽ, ഒരു നോഡ് ഒരു കമ്പ്യൂട്ടറോ വെർച്വൽ മെഷീനോ ആകാം. നിങ്ങൾ ഒരു കണ്ടെയ്‌നറൈസ്ഡ് ആപ്ലിക്കേഷൻ വിന്യസിക്കുന്ന ഒരൊറ്റ യൂണിറ്റായി കണക്കാക്കാവുന്ന നോഡുകളുടെ ഒരു ശേഖരമാണ് ക്ലസ്റ്റർ.
• കായ്കൾ. കുബെർനെറ്റസിൽ, കണ്ടെയ്നറുകൾ പോഡുകളിൽ പ്രവർത്തിക്കുന്നു. കുബർനെറ്റസിലെ ഒരു പോഡ് ഒരു അവിഭാജ്യ യൂണിറ്റാണ്. ഒരു പോഡ് ഒന്നോ അതിലധികമോ കണ്ടെയ്നറുകൾ സൂക്ഷിക്കുന്നു. നിങ്ങൾ സെർവർ കണ്ടെയ്നറുകൾ വിന്യസിക്കുന്നു ഒപ്പം ലോഡ്ജെൻ പ്രത്യേക കായ്കളിൽ. ഒരു പോഡിൽ നിരവധി കണ്ടെയ്‌നറുകൾ ഉള്ളപ്പോൾ (ഉദാഹരണത്തിന്, ഒരു ആപ്ലിക്കേഷൻ സെർവർ ഒപ്പം പ്രോക്സി സെര്വര്), കണ്ടെയ്‌നറുകൾ ഒരൊറ്റ എൻ്റിറ്റിയായി നിയന്ത്രിക്കുകയും പോഡ് ഉറവിടങ്ങൾ പങ്കിടുകയും ചെയ്യുന്നു.
• വിന്യാസങ്ങൾ. കുബെർനെറ്റസിൽ, ഒരേ പോഡുകളുടെ ശേഖരമായ ഒരു വസ്തുവാണ് വിന്യാസം. വിന്യാസം ക്ലസ്റ്റർ നോഡുകളിലുടനീളം വിതരണം ചെയ്യുന്ന പോഡുകളുടെ ഒന്നിലധികം പകർപ്പുകൾ സമാരംഭിക്കുന്നു. വിന്യാസം പരാജയപ്പെട്ടതോ പ്രതികരിക്കാത്തതോ ആയ പോഡുകൾ സ്വയമേവ മാറ്റിസ്ഥാപിക്കുന്നു.
• കുബെർനെറ്റസ് സേവനം. GKE-യിൽ ആപ്ലിക്കേഷൻ കോഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, തമ്മിലുള്ള കണക്ഷൻ ലോഡ്ജെൻ и സെർവർ. നിങ്ങൾ ഒരു ക്ലൗഡ് ഷെൽ വെർച്വൽ മെഷീനിലോ ഡെസ്ക്ടോപ്പിലോ സേവനങ്ങൾ ആരംഭിച്ചപ്പോൾ, നിങ്ങൾ അഭ്യർത്ഥനകൾ അയച്ചു സെർവർ по адресу localhost: 8080. GKE-ലേക്ക് വിന്യസിച്ചുകഴിഞ്ഞാൽ, ലഭ്യമായ നോഡുകളിൽ പോഡുകൾ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. ഡിഫോൾട്ടായി, പോഡ് ഏത് നോഡിലാണ് പ്രവർത്തിക്കുന്നതെന്ന് നിങ്ങൾക്ക് നിയന്ത്രണമില്ല, അതിനാൽ നിങ്ങൾക്ക് കായ്കൾ സ്ഥിരമായ IP വിലാസങ്ങളില്ല.
  ഒരു ഐപി വിലാസം ലഭിക്കുന്നതിന് സെർവർ, നിങ്ങൾ പോഡുകളുടെ മുകളിൽ ഒരു നെറ്റ്‌വർക്ക് അമൂർത്തീകരണം നിർവ്വചിക്കേണ്ടതുണ്ട്. അതാണ് അത് കുബർനെറ്റസ് സേവനം. കുബർനെറ്റസ് സേവനം ഒരു കൂട്ടം പോഡുകൾക്ക് സ്ഥിരമായ ഒരു എൻഡ് പോയിൻ്റ് നൽകുന്നു. കുറച്ച് ഉണ്ട് സേവനങ്ങളുടെ തരങ്ങൾ. സെർവർ ഉപയോഗിക്കുന്നു ലോഡ്ബാലൻസർ, ബന്ധപ്പെടാൻ ഒരു ബാഹ്യ IP വിലാസം നൽകുന്നു സെർവർ ക്ലസ്റ്ററിന് പുറത്ത് നിന്ന്.
  ഡിഎൻഎസ് പേരുകൾ നൽകുന്ന ഒരു ബിൽറ്റ്-ഇൻ ഡിഎൻഎസ് സിസ്റ്റവും കുബർനെറ്റസിനുണ്ട് (ഉദാഹരണത്തിന്, helloserver.default.cluster.local) സേവനങ്ങള്. ഇതിന് നന്ദി, ക്ലസ്റ്ററിനുള്ളിലെ പോഡുകൾ ക്ലസ്റ്ററിലെ മറ്റ് പോഡുകളുമായി സ്ഥിരമായ വിലാസത്തിൽ ആശയവിനിമയം നടത്തുന്നു. ക്ലൗഡ് ഷെല്ലിലോ കമ്പ്യൂട്ടറിലോ പോലുള്ള ക്ലസ്റ്ററിന് പുറത്ത് DNS പേര് ഉപയോഗിക്കാൻ കഴിയില്ല.

കുബർനെറ്റസ് പ്രകടമാക്കുന്നു

നിങ്ങൾ ഉറവിടത്തിൽ നിന്ന് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുമ്പോൾ, നിങ്ങൾ നിർബന്ധിത കമാൻഡ് ഉപയോഗിച്ചു പൈത്തൺ 3

server.py

നിർബന്ധിതം ഒരു ക്രിയയെ സൂചിപ്പിക്കുന്നു: "ഇത് ചെയ്യുക."

കുബെർനെറ്റസ് ഉപയോഗിക്കുന്നു പ്രഖ്യാപന മാതൃക. ഇതിനർത്ഥം ഞങ്ങൾ കുബെർനെറ്റിനോട് കൃത്യമായി എന്താണ് ചെയ്യേണ്ടതെന്ന് പറയുന്നില്ല, മറിച്ച് ആവശ്യമുള്ള അവസ്ഥയെ വിവരിക്കുകയാണ്. ഉദാഹരണത്തിന്, സിസ്റ്റത്തിൻ്റെ യഥാർത്ഥ അവസ്ഥ ആവശ്യമുള്ള അവസ്ഥയുമായി പൊരുത്തപ്പെടുന്നതിന് ആവശ്യമായ പോഡുകൾ കുബർനെറ്റസ് ആരംഭിക്കുകയും നിർത്തുകയും ചെയ്യുന്നു.

മാനിഫെസ്റ്റുകളിലോ ഫയലുകളിലോ നിങ്ങൾ ആവശ്യമുള്ള അവസ്ഥ സൂചിപ്പിക്കുന്നു YAML. ഒരു YAML ഫയലിൽ ഒന്നോ അതിലധികമോ Kubernetes ഒബ്‌ജക്‌റ്റുകൾക്കായുള്ള സ്പെസിഫിക്കേഷനുകൾ അടങ്ങിയിരിക്കുന്നു.

ഉദാഹരണത്തിൽ ഒരു 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

• ദയയോടെ വസ്തുവിൻ്റെ തരം സൂചിപ്പിക്കുന്നു.
• മെറ്റാഡാറ്റ.പേര് വിന്യാസത്തിൻ്റെ പേര് വ്യക്തമാക്കുന്നു.
• ആദ്യ ഫീൽഡ് സ്പെക്ക് ആവശ്യമുള്ള അവസ്ഥയുടെ ഒരു വിവരണം അടങ്ങിയിരിക്കുന്നു.
• 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 в Dockerfile തുറമുഖങ്ങൾ നൽകിയില്ല. നിങ്ങൾ തുറമുഖം നൽകുന്നു 8080അതിനാൽ നിങ്ങൾക്ക് കണ്ടെയ്നറുമായി ബന്ധപ്പെടാം സെർവർ ക്ലസ്റ്ററിന് പുറത്ത്. ഞങ്ങളുടെ കാര്യത്തിൽ hellosvc.default.cluster.local:80 (ഹ്രസ്വ നാമം: hellosvc) പോർട്ടുമായി യോജിക്കുന്നു 8080 പോഡ് ഐപി വിലാസങ്ങൾ helloserver.
• തുറമുഖം: ക്ലസ്റ്ററിലെ മറ്റ് സേവനങ്ങൾ അഭ്യർത്ഥനകൾ അയയ്ക്കുന്ന പോർട്ട് നമ്പറാണിത്.

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

ഒരിക്കല് ലോഡ്ജെൻ ഫീൽഡിനായി ഇൻകമിംഗ് അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നില്ല ടൈപ്പ് ചെയ്യുക സൂചിപ്പിച്ചു ClusterIP. ഈ തരം ക്ലസ്റ്ററിലെ സേവനങ്ങൾക്ക് ഉപയോഗിക്കാൻ കഴിയുന്ന ഒരു സ്ഥിരമായ 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 പ്രോജക്റ്റ് ഐഡിയിലേക്ക്.
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 പ്രോജക്റ്റ് ഐഡിയിലേക്ക്.
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) ബാഹ്യ ഐപി വിലാസങ്ങൾ നേടുക hellosvc:

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) ഒരു അഭ്യർത്ഥന അയയ്ക്കുക hellosvc: പകരം EXTERNAL_IP ബാഹ്യ IP വിലാസത്തിലേക്ക് hellosvc.

curl http://EXTERNAL_IP

നമുക്ക് ഇസ്തിയോ എടുക്കാം

നിങ്ങൾക്ക് ഇതിനകം തന്നെ GKE-ലേക്ക് ഒരു ആപ്ലിക്കേഷൻ വിന്യസിച്ചിട്ടുണ്ട്. ലോഡ്ജെൻ Kubernetes DNS ഉപയോഗിക്കാം (hellovc:80) എന്നതിലേക്ക് അഭ്യർത്ഥനകൾ അയക്കാൻ സെർവർഎന്നതിലേക്ക് നിങ്ങൾക്ക് അഭ്യർത്ഥനകൾ അയക്കാം സെർവർ ബാഹ്യ IP വിലാസം വഴി. Kubernetes-ന് നിരവധി സവിശേഷതകൾ ഉണ്ടെങ്കിലും, സേവനങ്ങളെക്കുറിച്ച് ചില വിവരങ്ങൾ നഷ്‌ടമായിട്ടുണ്ട്:

• സേവനങ്ങൾ എങ്ങനെയാണ് ഇടപെടുന്നത്? സേവനങ്ങൾ തമ്മിലുള്ള ബന്ധം എന്താണ്? സേവനങ്ങൾക്കിടയിൽ ട്രാഫിക് എങ്ങനെ ഒഴുകുന്നു? അത് താങ്കൾക്ക് അറിയാമോ ലോഡ്ജെൻ എന്നതിലേക്ക് അഭ്യർത്ഥനകൾ അയയ്ക്കുന്നു സെർവർ, എന്നാൽ നിങ്ങൾക്ക് ആപ്ലിക്കേഷനെ കുറിച്ച് ഒന്നും അറിയില്ലെന്ന് സങ്കൽപ്പിക്കുക. ഈ ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകാൻ, GKE-യിൽ പ്രവർത്തിക്കുന്ന പോഡുകളുടെ പട്ടിക നോക്കാം.
• മെട്രിക്സ്. എത്രകാലം സെർവർ ഒരു ഇൻകമിംഗ് അഭ്യർത്ഥനയോട് പ്രതികരിക്കുമോ? സെർവറിന് സെക്കൻഡിൽ എത്ര അഭ്യർത്ഥനകൾ ലഭിക്കുന്നു? ഇത് പിശക് സന്ദേശങ്ങൾ നൽകുന്നുണ്ടോ?
• സുരക്ഷാ വിവരങ്ങൾ. ഇടയിൽ ഗതാഗതം ലോഡ്ജെൻ и സെർവർ വെറുതെ കടന്നുപോകുന്നു HTTP അല്ലെങ്കിൽ വഴി mTLS?

ഈ ചോദ്യങ്ങൾക്കെല്ലാം ഇസ്തിയോ ഉത്തരം നൽകുന്നു. ഇത് ചെയ്യുന്നതിന്, ഇസ്തിയോ ഒരു സൈഡ്കാർ പ്രോക്സി സ്ഥാപിക്കുന്നു എൻവയ്ക്കൊപ്പം ഓരോ പോഡിലും. ആപ്ലിക്കേഷൻ കണ്ടെയ്‌നറുകളിലേക്കുള്ള എല്ലാ ഇൻകമിംഗ്, ഔട്ട്‌ഗോയിംഗ് ട്രാഫിക്കും എൻവോയ് പ്രോക്‌സി തടസ്സപ്പെടുത്തുന്നു. അതിനർത്ഥം അതാണ് സെർവർ и ലോഡ്ജെൻ സൈഡ്കാർ പ്രോക്സി എൻവോയ് വഴിയും എല്ലാ ട്രാഫിക്കിലൂടെയും സ്വീകരിക്കുക ലോഡ്ജെൻ к സെർവർ എൻവോയ് പ്രോക്സി വഴി പോകുന്നു.

എൻവോയ് പ്രോക്സികൾ തമ്മിലുള്ള കണക്ഷനുകൾ ഒരു സേവന മെഷ് ഉണ്ടാക്കുന്നു. സേവന മെഷ് ആർക്കിടെക്ചർ കുബർനെറ്റിൻ്റെ മുകളിൽ നിയന്ത്രണത്തിൻ്റെ ഒരു പാളി നൽകുന്നു.

എൻവോയ് പ്രോക്‌സികൾ അവരുടെ സ്വന്തം കണ്ടെയ്‌നറുകളിൽ പ്രവർത്തിക്കുന്നതിനാൽ, ആപ്ലിക്കേഷൻ കോഡിൽ മിക്കവാറും മാറ്റങ്ങളൊന്നുമില്ലാതെ ഒരു GKE ക്ലസ്റ്ററിന് മുകളിൽ Istio ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും. എന്നാൽ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ Istio നിയന്ത്രിക്കുന്നതിന് തയ്യാറാക്കാൻ നിങ്ങൾ കുറച്ച് ജോലി ചെയ്തു:

• എല്ലാ കണ്ടെയ്‌നറുകൾക്കുമുള്ള സേവനങ്ങൾ. വിന്യാസങ്ങളിലേക്ക് സെർവർ и ലോഡ്ജെൻ കുബർനെറ്റസ് സേവനവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. പോലും ലോഡ്ജെൻ, ഇൻകമിംഗ് അഭ്യർത്ഥനകൾ ലഭിക്കാത്ത, ഒരു സേവനമുണ്ട്.
• സേവനങ്ങളിലെ തുറമുഖങ്ങൾക്ക് പേരുകൾ ഉണ്ടായിരിക്കണം. സേവന പോർട്ടുകൾ GKE-യിൽ പേരിടാതെ വിടാമെങ്കിലും, നിങ്ങൾ വ്യക്തമാക്കാൻ ഇസ്തിയോ ആവശ്യപ്പെടുന്നു പോർട്ട് നാമം അവൻ്റെ പ്രോട്ടോക്കോൾ അനുസരിച്ച്. YAML ഫയലിൽ ഇതിനായി പോർട്ട് സെർവർ വിളിക്കുന്നു http:കാരണം സെർവർ പ്രോട്ടോക്കോൾ ഉപയോഗിക്കുന്നു HTTP. എങ്കിൽ സേവനം ഉപയോഗിച്ചു gRPC, നിങ്ങൾ തുറമുഖത്തിന് പേരിടും grpc.
• വിന്യാസങ്ങൾ ഫ്ലാഗ് ചെയ്തു. അതിനാൽ, ഒരേ സേവനത്തിൻ്റെ പതിപ്പുകൾക്കിടയിൽ ട്രാഫിക് വിഭജിക്കുന്നത് പോലെയുള്ള ഇസ്തിയോയുടെ ട്രാഫിക് മാനേജ്മെൻ്റ് സവിശേഷതകൾ നിങ്ങൾക്ക് ഉപയോഗിക്കാം.

ഇസ്തിയോ ഇൻസ്റ്റാൾ ചെയ്യുന്നു

ഇസ്തിയോ ഇൻസ്റ്റാൾ ചെയ്യാൻ രണ്ട് വഴികളുണ്ട്. കഴിയും GKE വിപുലീകരണത്തിൽ Istio പ്രവർത്തനക്ഷമമാക്കുക അഥവാ ഇസ്തിയോയുടെ ഓപ്പൺ സോഴ്സ് പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്യുക ക്ലസ്റ്ററിൽ. GKE-ലെ ഇസ്തിയോ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് GKE ക്ലസ്റ്റർ ലൈഫ് സൈക്കിളിലുടനീളം ഇസ്തിയോ ഇൻസ്റ്റാളേഷനുകളും അപ്‌ഗ്രേഡുകളും എളുപ്പത്തിൽ നിയന്ത്രിക്കാനാകും. നിങ്ങൾക്ക് ഇസ്തിയോയുടെ ഏറ്റവും പുതിയ പതിപ്പോ നിങ്ങളുടെ ഇസ്തിയോ കൺട്രോൾ പാനൽ കോൺഫിഗറേഷനിൽ കൂടുതൽ നിയന്ത്രണമോ വേണമെങ്കിൽ, GKE വിപുലീകരണത്തിലെ Istio-ന് പകരം ഓപ്പൺ സോഴ്‌സ് പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്യുക. സമീപനം തീരുമാനിക്കാൻ, ലേഖനം വായിക്കുക GKE-യിൽ എനിക്ക് ഇസ്തിയോ ആവശ്യമുണ്ടോ?.

ഒരു ഓപ്ഷൻ തിരഞ്ഞെടുക്കുക, ഉചിതമായ ഗൈഡ് അവലോകനം ചെയ്യുക, നിങ്ങളുടെ ക്ലസ്റ്ററിൽ Istio ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ പാലിക്കുക. നിങ്ങൾ പുതുതായി വിന്യസിച്ച ആപ്ലിക്കേഷനുമായി ഇസ്തിയോ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, സൈഡ്കാർ നടപ്പിലാക്കൽ പ്രാപ്തമാക്കുക നെയിംസ്പേസിനായി സ്ഥിരസ്ഥിതി.

വൃത്തിയാക്കൽ

ഈ ട്യൂട്ടോറിയലിൽ നിങ്ങൾ ഉപയോഗിച്ച ഉറവിടങ്ങൾക്കായി നിങ്ങളുടെ Google ക്ലൗഡ് പ്ലാറ്റ്‌ഫോം അക്കൗണ്ടിലേക്ക് നിരക്ക് ഈടാക്കുന്നത് ഒഴിവാക്കാൻ, നിങ്ങൾ Istio ഇൻസ്റ്റാൾ ചെയ്‌ത് സാമ്പിൾ ആപ്ലിക്കേഷൻ ഉപയോഗിച്ച് കളിച്ചുകഴിഞ്ഞാൽ കണ്ടെയ്‌നർ ക്ലസ്റ്റർ ഇല്ലാതാക്കുക. ഇത് കമ്പ്യൂട്ട് ഇൻസ്‌റ്റൻസുകൾ, ഡിസ്‌കുകൾ, നെറ്റ്‌വർക്ക് ഉറവിടങ്ങൾ എന്നിവ പോലുള്ള എല്ലാ ക്ലസ്റ്റർ ഉറവിടങ്ങളും നീക്കം ചെയ്യും.

അടുത്തത് എന്ത്?

• ഇനിപ്പറയുന്ന സാങ്കേതികവിദ്യകൾ പര്യവേക്ഷണം ചെയ്യുക:

  1. ഡോക്കർ
  2. കണ്ടെയ്നറുകൾ
  3. കണ്ടെയ്നർ രജിസ്ട്രി
  4. കുബേർനെറ്റ്
  5. ജി.കെ.ഇ
  6. സേവന മെഷ്
  7. ഇസ്തോ

• ഇനിപ്പറയുന്ന ഉപകരണങ്ങൾ പര്യവേക്ഷണം ചെയ്യുക:

  1. ക്ലൗഡ് SDK
  2. വഴികാട്ടി gCloud
  3. കുബെക്ലി
  4. ഡോക്കർ

• കുബർനെറ്റസ് ആശയങ്ങൾ പഠിക്കുക:

  1. ക്ലസ്റ്ററുകൾ
  2. നോഡുകൾ
  3. കായ്കൾ
  4. സേവനങ്ങൾ
  5. വിന്യാസം

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