Istio ਲਈ ਅਰਜ਼ੀ ਤਿਆਰ ਕਰ ਰਿਹਾ ਹੈ

Istio ਵੰਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਜੋੜਨ, ਸੁਰੱਖਿਅਤ ਕਰਨ ਅਤੇ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਸਾਧਨ ਹੈ। Istio ਪੈਮਾਨੇ 'ਤੇ ਸੌਫਟਵੇਅਰ ਨੂੰ ਚਲਾਉਣ ਅਤੇ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ ਕਈ ਤਰ੍ਹਾਂ ਦੀਆਂ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਨੂੰ ਪੈਕੇਜ ਕਰਨ ਲਈ ਕੰਟੇਨਰ ਅਤੇ ਤੈਨਾਤੀ ਲਈ ਨਿਰਭਰਤਾਵਾਂ, ਅਤੇ ਉਨ੍ਹਾਂ ਕੰਟੇਨਰਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕੁਬਰਨੇਟਸ ਸ਼ਾਮਲ ਹਨ। ਇਸ ਲਈ, Istio ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਇਹ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇਹਨਾਂ ਤਕਨਾਲੋਜੀਆਂ 'ਤੇ ਆਧਾਰਿਤ ਕਈ ਸੇਵਾਵਾਂ ਵਾਲੀ ਐਪਲੀਕੇਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ ਬਿਨਾ ਇਸਟੀਓ. ਜੇਕਰ ਇਹ ਟੂਲ ਅਤੇ ਸੰਕਲਪ ਤੁਹਾਡੇ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਜਾਣੂ ਹਨ, ਤਾਂ ਇਸ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਛੱਡਣ ਲਈ ਬੇਝਿਜਕ ਹੋਵੋ ਅਤੇ ਸਿੱਧੇ ਭਾਗ 'ਤੇ ਜਾਓ। ਗੂਗਲ ਕੁਬਰਨੇਟਸ ਇੰਜਣ (ਜੀ.ਕੇ.ਈ.) 'ਤੇ ਇਸਟੀਓ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ ਜਾਂ ਇੱਕ ਐਕਸਟੈਂਸ਼ਨ ਸਥਾਪਤ ਕਰਨਾ GKE 'ਤੇ Istio.

ਇਹ ਇੱਕ ਕਦਮ-ਦਰ-ਕਦਮ ਗਾਈਡ ਹੈ ਜਿੱਥੇ ਅਸੀਂ ਤੁਹਾਨੂੰ ਇੱਕ ਉਦਾਹਰਣ ਰਾਹੀਂ ਇਹਨਾਂ ਤਕਨਾਲੋਜੀਆਂ ਦੀ ਬੁਨਿਆਦੀ ਸਮਝ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਸਰੋਤ ਕੋਡ ਤੋਂ GKE ਕੰਟੇਨਰ ਤੱਕ ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਚੱਲਾਂਗੇ। ਤੁਸੀਂ ਇਹ ਵੀ ਦੇਖੋਗੇ ਕਿ ਕਿਵੇਂ Istio ਇਹਨਾਂ ਤਕਨਾਲੋਜੀਆਂ ਦੀ ਸ਼ਕਤੀ ਦਾ ਲਾਭ ਉਠਾਉਂਦਾ ਹੈ। ਇਹ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕੰਟੇਨਰਾਂ, ਕੁਬਰਨੇਟਸ, ਸਰਵਿਸ ਮੇਸ਼ਾਂ, ਜਾਂ ਇਸਟੀਓ ਬਾਰੇ ਕੁਝ ਨਹੀਂ ਜਾਣਦੇ ਹੋ।

ਕੰਮ

ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮਾਂ ਨੂੰ ਪੂਰਾ ਕਰੋਗੇ:

1. ਮਲਟੀਪਲ ਸੇਵਾਵਾਂ ਦੇ ਨਾਲ ਇੱਕ ਸਧਾਰਨ ਹੈਲੋ ਵਰਲਡ ਐਪਲੀਕੇਸ਼ਨ ਸਿੱਖਣਾ।
2. ਸਰੋਤ ਕੋਡ ਤੋਂ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਓ।
3. ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੰਟੇਨਰਾਂ ਵਿੱਚ ਪੈਕ ਕਰਨਾ।
4. ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਬਣਾਉਣਾ।
5. ਕੰਟੇਨਰਾਂ ਨੂੰ ਕਲੱਸਟਰ ਵਿੱਚ ਤੈਨਾਤ ਕਰਨਾ।

ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ

Kubernetes Engine API ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:

1. ਜਾਓ ਕੁਬਰਨੇਟਸ ਇੰਜਣ ਪੰਨਾ Google ਕਲਾਊਡ ਪਲੇਟਫਾਰਮ ਕੰਸੋਲ ਵਿੱਚ।
2. ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ ਜਾਂ ਚੁਣੋ।
3. API ਅਤੇ ਸੰਬੰਧਿਤ ਸੇਵਾਵਾਂ ਦੇ ਸਮਰੱਥ ਹੋਣ ਤੱਕ ਉਡੀਕ ਕਰੋ। ਇਸ ਵਿੱਚ ਕੁਝ ਮਿੰਟ ਲੱਗ ਸਕਦੇ ਹਨ।
4. ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ Google ਕਲਾਊਡ ਪਲੇਟਫਾਰਮ ਪ੍ਰੋਜੈਕਟ ਲਈ ਬਿਲਿੰਗ ਸੈੱਟਅੱਪ ਕੀਤੀ ਗਈ ਹੈ। ਜਾਣੋ ਕਿ ਬਿਲਿੰਗ ਨੂੰ ਕਿਵੇਂ ਸਮਰੱਥ ਕਰਨਾ ਹੈ.

ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ, ਤੁਸੀਂ ਕਲਾਉਡ ਸ਼ੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੂੰ ਤਿਆਰ ਕਰਦਾ ਹੈ g1-Google ਕੰਪਿਊਟ ਇੰਜਣ ਵਿੱਚ ਛੋਟਾ ਡੇਬੀਅਨ-ਅਧਾਰਿਤ Linux, ਜਾਂ ਇੱਕ Linux ਜਾਂ macOS ਕੰਪਿਊਟਰ ਨਾਲ।

ਵਿਕਲਪ A: ਕਲਾਉਡ ਸ਼ੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਕਲਾਉਡ ਸ਼ੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਫਾਇਦੇ:

• Python 2 ਅਤੇ Python 3 ਵਿਕਾਸ ਵਾਤਾਵਰਣ (ਸਮੇਤ virtualenv) ਪੂਰੀ ਤਰ੍ਹਾਂ ਸੰਰਚਿਤ ਹਨ।
• ਕਮਾਂਡ ਲਾਈਨ ਟੂਲ gcloud, ਡੌਕਰ, Git и kubectl, ਜੋ ਅਸੀਂ ਵਰਤਾਂਗੇ, ਪਹਿਲਾਂ ਹੀ ਇੰਸਟਾਲ ਹਨ।
• ਤੁਹਾਡੇ ਕੋਲ ਚੁਣਨ ਲਈ ਕਈ ਹਨ ਪਾਠ ਸੰਪਾਦਕ:
  1. ਕੋਡ ਸੰਪਾਦਕ, ਜੋ ਕਿ ਕਲਾਉਡ ਸ਼ੈੱਲ ਵਿੰਡੋ ਦੇ ਸਿਖਰ 'ਤੇ ਸੰਪਾਦਨ ਆਈਕਨ ਨਾਲ ਖੁੱਲ੍ਹਦਾ ਹੈ।
  2. Emacs, Vim ਜਾਂ Nano, ਜੋ ਕਿ ਕਲਾਉਡ ਸ਼ੈੱਲ ਵਿੱਚ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਖੁੱਲ੍ਹਦੇ ਹਨ।

ਵਰਤਣ ਲਈ ਕਲਾਉਡ ਸ਼ੈਲ:

1. GCP ਕੰਸੋਲ 'ਤੇ ਜਾਓ।
2. ਪ੍ਰੈਸ ਕਲਾਊਡ ਸ਼ੈੱਲ ਨੂੰ ਸਰਗਰਮ ਕਰੋ GCP ਕੰਸੋਲ ਵਿੰਡੋ ਦੇ ਸਿਖਰ 'ਤੇ (ਕਲਾਊਡ ਸ਼ੈੱਲ ਨੂੰ ਸਰਗਰਮ ਕਰੋ)।

ਹੇਠਲੇ ਹਿੱਸੇ ਵਿੱਚ GCP ਕੰਸੋਲ ਕਮਾਂਡ ਲਾਈਨ ਦੇ ਨਾਲ ਇੱਕ ਕਲਾਉਡ ਸ਼ੈੱਲ ਸੈਸ਼ਨ ਇੱਕ ਨਵੀਂ ਵਿੰਡੋ ਵਿੱਚ ਖੁੱਲ੍ਹੇਗਾ।

ਵਿਕਲਪ B: ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਕਮਾਂਡ ਲਾਈਨ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਜੇਕਰ ਤੁਸੀਂ Linux ਜਾਂ macOS 'ਤੇ ਚੱਲ ਰਹੇ ਕੰਪਿਊਟਰ 'ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਪੋਨੈਂਟਸ ਨੂੰ ਕੌਂਫਿਗਰ ਅਤੇ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ:

1. ਅਨੁਕੂਲ ਬਣਾਉ Python 3 ਅਤੇ Python 2 ਵਿਕਾਸ ਵਾਤਾਵਰਣ.

2. ਕਲਾਊਡ SDK ਸਥਾਪਤ ਕਰੋ ਕਮਾਂਡ ਲਾਈਨ ਟੂਲ ਨਾਲ gcloud.

3. ਸੈੱਟ ਕਰੋ kubectl - ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕਮਾਂਡ ਲਾਈਨ ਟੂਲ ਕਬਰਨੇਟਿਸ.

   gcloud components install kubectl

4. ਸੈੱਟ ਕਰੋ ਡੌਕਰ ਕਮਿਊਨਿਟੀ ਐਡੀਸ਼ਨ (CE). ਤੁਸੀਂ ਕਮਾਂਡ ਲਾਈਨ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇ ਡੌਕਰਨਮੂਨਾ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਕੰਟੇਨਰ ਚਿੱਤਰ ਬਣਾਉਣ ਲਈ.

5. ਸੰਦ ਨੂੰ ਇੰਸਟਾਲ ਕਰੋ Git ਸੰਸਕਰਣ ਨਿਯੰਤਰਣGitHub ਤੋਂ ਨਮੂਨਾ ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ.

ਨਮੂਨਾ ਕੋਡ ਡਾਊਨਲੋਡ ਕਰੋ

1. ਸਰੋਤ ਕੋਡ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੋ ਹੈਲੋਸਰਵਰ:

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

2. ਉਦਾਹਰਨ ਕੋਡ ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਜਾਓ:

   cd istio-samples/sample-apps/helloserver

ਕਈ ਸੇਵਾਵਾਂ ਦੇ ਨਾਲ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

ਨਮੂਨਾ ਐਪਲੀਕੇਸ਼ਨ ਪਾਈਥਨ ਵਿੱਚ ਲਿਖੀ ਗਈ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਦੋ ਭਾਗ ਹਨ ਜੋ ਵਰਤਦੇ ਹੋਏ ਇੰਟਰੈਕਟ ਕਰਦੇ ਹਨ ਆਰਾਮ:

• ਸਰਵਰ: ਇੱਕ ਅੰਤ ਬਿੰਦੂ ਦੇ ਨਾਲ ਸਧਾਰਨ ਸਰਵਰ ਪ੍ਰਾਪਤ ਕਰੋ, /, ਜੋ ਕੰਸੋਲ 'ਤੇ "ਹੈਲੋ ਵਰਲਡ" ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ।
• ਲੋਡਜਨ: ਸਕ੍ਰਿਪਟ ਜੋ ਟ੍ਰੈਫਿਕ ਭੇਜਦੀ ਹੈ ਸਰਵਰ, ਪ੍ਰਤੀ ਸਕਿੰਟ ਬੇਨਤੀਆਂ ਦੀ ਸੰਰਚਨਾਯੋਗ ਸੰਖਿਆ ਦੇ ਨਾਲ।

ਸਰੋਤ ਕੋਡ ਤੋਂ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾ ਰਿਹਾ ਹੈ

ਨਮੂਨਾ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਪੜਚੋਲ ਕਰਨ ਲਈ, ਇਸਨੂੰ ਕਲਾਉਡ ਸ਼ੈੱਲ ਵਿੱਚ ਜਾਂ ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ ਚਲਾਓ।
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 'ਤੇ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਨਮੂਨਾ ਐਪਲੀਕੇਸ਼ਨ - ਨੂੰ ਪੈਕੇਜ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਸਰਵਰ и ਲੋਡਜਨ - at ਡੱਬੇ. ਇੱਕ ਕੰਟੇਨਰ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇਸਦੇ ਵਾਤਾਵਰਣ ਤੋਂ ਅਲੱਗ ਕਰਨ ਲਈ ਪੈਕੇਜ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ।

ਇੱਕ ਕੰਟੇਨਰ ਵਿੱਚ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਪੈਕ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ ਡੌਕਰਫਾਈਲ. ਡੌਕਰਫਾਈਲ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਹੈ ਜੋ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਸਰੋਤ ਕੋਡ ਅਤੇ ਇਸਦੀ ਨਿਰਭਰਤਾ ਨੂੰ ਬਣਾਉਣ ਲਈ ਕਮਾਂਡਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ ਡੌਕਰ ਚਿੱਤਰ। ਇੱਕ ਵਾਰ ਬਣ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਚਿੱਤਰ ਨੂੰ ਇੱਕ ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ਵਿੱਚ ਅੱਪਲੋਡ ਕਰੋ ਜਿਵੇਂ ਕਿ ਡੌਕਰ ਹੱਬ ਜਾਂ ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ.

ਉਦਾਹਰਣ ਪਹਿਲਾਂ ਹੀ ਹੈ ਡੌਕਰਫਾਈਲ ਨੂੰ ਸਰਵਰ и ਲੋਡਜਨ ਚਿੱਤਰਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ ਸਾਰੀਆਂ ਜ਼ਰੂਰੀ ਕਮਾਂਡਾਂ ਦੇ ਨਾਲ। ਹੇਠਾਂ - ਡੌਕਰਫਾਈਲ ਨੂੰ ਸਰਵਰ:

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) ਕੰਟੇਨਰ ਦੇ ਫਾਈਲ ਸਿਸਟਮ ਲਈ।
• ENTRYPOINT ਕਮਾਂਡ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਕੰਟੇਨਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਕਮਾਂਡ ਲਗਭਗ ਉਹੀ ਹੈ ਜੋ ਤੁਸੀਂ ਚਲਾਉਂਦੇ ਸੀ server.py ਸਰੋਤ ਕੋਡ ਤੋਂ.
• ਦੀ ਟੀਮ ਐਕਸਪੋਜ਼ ਕਰੋ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਸਰਵਰ ਪੋਰਟ ਰਾਹੀਂ ਡੇਟਾ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ 8080. ਇਹ ਟੀਮ ਨਹੀਂ ਹੈ ਪੋਰਟ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ. ਇਹ ਕੁਝ ਕਿਸਮ ਦਾ ਦਸਤਾਵੇਜ਼ ਹੈ ਜੋ ਪੋਰਟ ਖੋਲ੍ਹਣ ਲਈ ਲੋੜੀਂਦਾ ਹੈ 8080 ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਕਰਨ ਵੇਲੇ.

ਤੁਹਾਡੀ ਅਰਜ਼ੀ ਨੂੰ ਕੰਟੇਨਰਾਈਜ਼ ਕਰਨ ਦੀ ਤਿਆਰੀ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ

1) ਹੇਠਾਂ ਦਿੱਤੇ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕਰੋ। ਬਦਲੋ PROJECT_ID ਤੁਹਾਡੀ GCP ਪ੍ਰੋਜੈਕਟ ਆਈ.ਡੀ.

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 ਵਿੱਚ, ਇੱਕ ਨੋਡ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਹੈ। ਹੋਰ ਕੁਬਰਨੇਟਸ ਪਲੇਟਫਾਰਮਾਂ 'ਤੇ, ਇੱਕ ਨੋਡ ਇੱਕ ਕੰਪਿਊਟਰ ਜਾਂ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਹੋ ਸਕਦਾ ਹੈ। ਇੱਕ ਕਲੱਸਟਰ ਨੋਡਾਂ ਦਾ ਇੱਕ ਸੰਗ੍ਰਹਿ ਹੁੰਦਾ ਹੈ ਜਿਸਨੂੰ ਇੱਕ ਸਿੰਗਲ ਯੂਨਿਟ ਮੰਨਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਇੱਕ ਕੰਟੇਨਰਾਈਜ਼ਡ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਹੋ।
• ਫਲੀਆਂ. ਕੁਬਰਨੇਟਸ ਵਿੱਚ, ਕੰਟੇਨਰ ਫਲੀਆਂ ਵਿੱਚ ਚੱਲਦੇ ਹਨ। ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਇੱਕ ਪੌਡ ਇੱਕ ਅਵਿਭਾਗੀ ਇਕਾਈ ਹੈ। ਇੱਕ ਪੌਡ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਡੱਬੇ ਹੁੰਦੇ ਹਨ। ਤੁਸੀਂ ਸਰਵਰ ਕੰਟੇਨਰ ਤੈਨਾਤ ਕਰਦੇ ਹੋ ਅਤੇ ਲੋਡਜਨ ਵੱਖਰੀਆਂ ਫਲੀਆਂ ਵਿੱਚ. ਜਦੋਂ ਇੱਕ ਪੌਡ ਵਿੱਚ ਕਈ ਕੰਟੇਨਰ ਹੁੰਦੇ ਹਨ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਸਰਵਰ ਅਤੇ ਪ੍ਰੌਕਸੀ ਸਰਵਰ), ਕੰਟੇਨਰਾਂ ਨੂੰ ਇੱਕ ਇਕਾਈ ਵਜੋਂ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਪੌਡ ਸਰੋਤ ਸਾਂਝੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
• ਤੈਨਾਤੀਆਂ. ਕੁਬਰਨੇਟਸ ਵਿੱਚ, ਇੱਕ ਤੈਨਾਤੀ ਇੱਕ ਵਸਤੂ ਹੈ ਜੋ ਇੱਕੋ ਜਿਹੇ ਪੌਡਾਂ ਦਾ ਸੰਗ੍ਰਹਿ ਹੈ। ਤੈਨਾਤੀ ਕਲੱਸਟਰ ਨੋਡਾਂ ਵਿੱਚ ਵੰਡੀਆਂ ਪੌਡਾਂ ਦੀਆਂ ਕਈ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਲਾਂਚ ਕਰਦੀ ਹੈ। ਤੈਨਾਤੀ ਉਹਨਾਂ ਪੌਡਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਬਦਲ ਦਿੰਦੀ ਹੈ ਜੋ ਅਸਫਲ ਹੋ ਗਈਆਂ ਹਨ ਜਾਂ ਗੈਰ-ਜਵਾਬਦੇਹ ਹਨ।
• ਕੁਬਰਨੇਟਸ ਸੇਵਾ. ਜਦੋਂ 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 ਲੋੜੀਦੀ ਸਥਿਤੀ ਦਾ ਵੇਰਵਾ ਰੱਖਦਾ ਹੈ।
• 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 ਪਤਾ ਹੁੰਦਾ ਹੈ ਅਤੇ ਕਲੱਸਟਰ ਦੇ ਬਾਹਰੋਂ ਪਹੁੰਚਯੋਗ ਹੁੰਦਾ ਹੈ।
• targetPort: ਜਿਵੇਂ ਕਿ ਤੁਹਾਨੂੰ ਯਾਦ ਹੈ, ਟੀਮ ਐਕਸਪੋਜ਼ 8080 в ਡੌਕਰਫਾਈਲ ਪੋਰਟ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤੀ। ਤੁਸੀਂ ਪੋਰਟ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋ 8080ਤਾਂ ਜੋ ਤੁਸੀਂ ਕੰਟੇਨਰ ਨਾਲ ਸੰਪਰਕ ਕਰ ਸਕੋ ਸਰਵਰ ਕਲੱਸਟਰ ਦੇ ਬਾਹਰ. ਸਾਡੇ ਕੇਸ ਵਿੱਚ hellosvc.default.cluster.local:80 (ਛੋਟਾ ਨਾਮ: ਹੈਲੋਸਵੀਸੀ) ਪੋਰਟ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ 8080 Pod 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

ਇੱਕ ਵਾਰ ਲੋਡਜਨ ਖੇਤਰ ਲਈ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਸਵੀਕਾਰ ਨਹੀਂ ਕਰਦਾ ਹੈ ਦੀ ਕਿਸਮ ਸੰਕੇਤ ਕੀਤਾ 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) ਬਾਹਰੀ 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 ਪਤੇ ਦੁਆਰਾ। ਹਾਲਾਂਕਿ ਕੁਬਰਨੇਟਸ ਦੀਆਂ ਬਹੁਤ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ, ਪਰ ਸੇਵਾਵਾਂ ਬਾਰੇ ਕੁਝ ਜਾਣਕਾਰੀ ਗੁੰਮ ਹੈ:

• ਸੇਵਾਵਾਂ ਕਿਵੇਂ ਅੰਤਰਕਿਰਿਆ ਕਰਦੀਆਂ ਹਨ? ਸੇਵਾਵਾਂ ਵਿਚਕਾਰ ਕੀ ਸਬੰਧ ਹਨ? ਸੇਵਾਵਾਂ ਵਿਚਕਾਰ ਆਵਾਜਾਈ ਕਿਵੇਂ ਚਲਦੀ ਹੈ? ਕੀ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਲੋਡਜਨ ਨੂੰ ਬੇਨਤੀਆਂ ਭੇਜਦਾ ਹੈ ਸਰਵਰ, ਪਰ ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਬਾਰੇ ਕੁਝ ਨਹੀਂ ਜਾਣਦੇ ਹੋ। ਇਹਨਾਂ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦੇਣ ਲਈ, ਆਓ ਜੀਕੇਈ ਵਿੱਚ ਚੱਲ ਰਹੇ ਪੌਡਾਂ ਦੀ ਸੂਚੀ ਵੇਖੀਏ।
• ਮੈਟ੍ਰਿਕਸ. ਕਿੰਨਾ ਲੰਬਾ ਸਰਵਰ ਇੱਕ ਆਉਣ ਵਾਲੀ ਬੇਨਤੀ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ? ਸਰਵਰ ਦੁਆਰਾ ਪ੍ਰਤੀ ਸਕਿੰਟ ਕਿੰਨੀਆਂ ਬੇਨਤੀਆਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ? ਕੀ ਇਹ ਗਲਤੀ ਸੁਨੇਹੇ ਦਿੰਦਾ ਹੈ?
• ਸੁਰੱਖਿਆ ਜਾਣਕਾਰੀ. ਵਿਚਕਾਰ ਆਵਾਜਾਈ ਲੋਡਜਨ и ਸਰਵਰ ਹੁਣੇ ਹੀ ਲੰਘਦਾ ਹੈ HTTP ਨੂੰ ਜਾਂ ਦੁਆਰਾ mTLS?

Istio ਇਹਨਾਂ ਸਾਰੇ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦਿੰਦਾ ਹੈ. ਅਜਿਹਾ ਕਰਨ ਲਈ, Istio ਇੱਕ ਸਾਈਡਕਾਰ ਪ੍ਰੌਕਸੀ ਰੱਖਦਾ ਹੈ ਦੂਤ ਹਰ ਇੱਕ ਪੋਡ ਵਿੱਚ. ਦੂਤ ਪ੍ਰੌਕਸੀ ਐਪਲੀਕੇਸ਼ਨ ਕੰਟੇਨਰਾਂ ਲਈ ਆਉਣ ਵਾਲੇ ਅਤੇ ਜਾਣ ਵਾਲੇ ਸਾਰੇ ਟ੍ਰੈਫਿਕ ਨੂੰ ਰੋਕਦਾ ਹੈ। ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਰਵਰ и ਲੋਡਜਨ ਸਾਈਡਕਾਰ ਪ੍ਰੌਕਸੀ ਦੂਤ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕਰੋ, ਅਤੇ ਇਸ ਤੋਂ ਸਾਰੇ ਟ੍ਰੈਫਿਕ ਲੋਡਜਨ к ਸਰਵਰ ਰਾਜਦੂਤ ਪ੍ਰੌਕਸੀ ਰਾਹੀਂ ਜਾਂਦਾ ਹੈ।

ਦੂਤ ਪ੍ਰੌਕਸੀ ਦੇ ਵਿਚਕਾਰ ਕਨੈਕਸ਼ਨ ਇੱਕ ਸੇਵਾ ਜਾਲ ਬਣਾਉਂਦੇ ਹਨ। ਸਰਵਿਸ ਮੈਸ਼ ਆਰਕੀਟੈਕਚਰ ਕੁਬਰਨੇਟਸ ਦੇ ਸਿਖਰ 'ਤੇ ਨਿਯੰਤਰਣ ਦੀ ਇੱਕ ਪਰਤ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਕਿਉਂਕਿ ਦੂਤ ਪ੍ਰੌਕਸੀ ਉਹਨਾਂ ਦੇ ਆਪਣੇ ਕੰਟੇਨਰਾਂ ਵਿੱਚ ਚਲਦੇ ਹਨ, ਇਸਤੀਓ ਨੂੰ ਇੱਕ GKE ਕਲੱਸਟਰ ਦੇ ਸਿਖਰ 'ਤੇ ਸਥਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਵਿੱਚ ਲਗਭਗ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਪਰ ਤੁਸੀਂ ਆਪਣੀ ਅਰਜ਼ੀ ਨੂੰ Istio ਦੁਆਰਾ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ ਤਿਆਰ ਕਰਨ ਲਈ ਕੁਝ ਕੰਮ ਕੀਤਾ ਹੈ:

• ਸਾਰੇ ਕੰਟੇਨਰਾਂ ਲਈ ਸੇਵਾਵਾਂ। ਤੈਨਾਤੀਆਂ ਨੂੰ ਸਰਵਰ и ਲੋਡਜਨ ਕੁਬਰਨੇਟਸ ਸੇਵਾ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਵੀ ਲੋਡਜਨ, ਜੋ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕਰਦੇ, ਉੱਥੇ ਇੱਕ ਸੇਵਾ ਹੈ।
• ਸੇਵਾਵਾਂ ਵਿੱਚ ਬੰਦਰਗਾਹਾਂ ਦੇ ਨਾਮ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। ਹਾਲਾਂਕਿ ਸੇਵਾ ਪੋਰਟਾਂ ਨੂੰ GKE ਵਿੱਚ ਨਾਮ ਰਹਿਤ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, Istio ਤੁਹਾਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਪੋਰਟ ਨਾਮ ਉਸਦੇ ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਅਨੁਸਾਰ. YAML ਫਾਈਲ ਵਿੱਚ ਲਈ ਪੋਰਟ ਸਰਵਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ httpਕਿਉਂਕਿ ਸਰਵਰ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ HTTP ਨੂੰ. ਜੇ ਸੇਵਾ ਵਰਤਿਆ ਜੀਆਰਪੀਸੀ, ਤੁਸੀਂ ਪੋਰਟ ਦਾ ਨਾਮ ਦੇਵੋਗੇ grpc.
• ਤੈਨਾਤੀਆਂ ਨੂੰ ਫਲੈਗ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਲਈ, ਤੁਸੀਂ Istio ਦੀਆਂ ਟ੍ਰੈਫਿਕ ਪ੍ਰਬੰਧਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਉਸੇ ਸੇਵਾ ਦੇ ਸੰਸਕਰਣਾਂ ਵਿਚਕਾਰ ਟ੍ਰੈਫਿਕ ਨੂੰ ਵੰਡਣਾ।

Istio ਇੰਸਟਾਲ ਕਰਨਾ

Istio ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ। ਸਕਦਾ ਹੈ GKE ਐਕਸਟੈਂਸ਼ਨ 'ਤੇ Istio ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ ਜ Istio ਦੇ ਓਪਨ ਸੋਰਸ ਸੰਸਕਰਣ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ ਕਲੱਸਟਰ 'ਤੇ. GKE 'ਤੇ Istio ਦੇ ਨਾਲ, ਤੁਸੀਂ GKE ਕਲੱਸਟਰ ਜੀਵਨ ਚੱਕਰ ਦੌਰਾਨ Istio ਸਥਾਪਨਾਵਾਂ ਅਤੇ ਅੱਪਗਰੇਡਾਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਤੁਸੀਂ Istio ਦਾ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਆਪਣੀ Istio ਕੰਟਰੋਲ ਪੈਨਲ ਸੰਰਚਨਾ 'ਤੇ ਵਧੇਰੇ ਨਿਯੰਤਰਣ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ GKE ਐਕਸਟੈਂਸ਼ਨ 'ਤੇ Istio ਦੀ ਬਜਾਏ ਓਪਨ ਸੋਰਸ ਸੰਸਕਰਣ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ। ਪਹੁੰਚ 'ਤੇ ਫੈਸਲਾ ਕਰਨ ਲਈ, ਲੇਖ ਪੜ੍ਹੋ ਕੀ ਮੈਨੂੰ GKE 'ਤੇ Istio ਦੀ ਲੋੜ ਹੈ?.

ਇੱਕ ਵਿਕਲਪ ਚੁਣੋ, ਉਚਿਤ ਗਾਈਡ ਦੀ ਸਮੀਖਿਆ ਕਰੋ, ਅਤੇ ਆਪਣੇ ਕਲੱਸਟਰ 'ਤੇ Istio ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ। ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੀ ਨਵੀਂ ਤੈਨਾਤ ਐਪਲੀਕੇਸ਼ਨ ਨਾਲ Istio ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਸਾਈਡਕਾਰ ਲਾਗੂ ਕਰਨ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ ਨੇਮਸਪੇਸ ਲਈ ਮੂਲ.

ਸਫਾਈ

ਤੁਹਾਡੇ ਦੁਆਰਾ ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਵਰਤੇ ਗਏ ਸਰੋਤਾਂ ਲਈ ਤੁਹਾਡੇ Google ਕਲਾਉਡ ਪਲੇਟਫਾਰਮ ਖਾਤੇ ਤੋਂ ਚਾਰਜ ਕੀਤੇ ਜਾਣ ਤੋਂ ਬਚਣ ਲਈ, ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ Istio ਸਥਾਪਤ ਕਰ ਲੈਂਦੇ ਹੋ ਅਤੇ ਨਮੂਨਾ ਐਪਲੀਕੇਸ਼ਨ ਨਾਲ ਖੇਡਦੇ ਹੋ ਤਾਂ ਕੰਟੇਨਰ ਕਲੱਸਟਰ ਨੂੰ ਮਿਟਾਓ। ਇਹ ਸਾਰੇ ਕਲੱਸਟਰ ਸਰੋਤਾਂ ਨੂੰ ਹਟਾ ਦੇਵੇਗਾ, ਜਿਵੇਂ ਕਿ ਗਣਨਾ ਉਦਾਹਰਨਾਂ, ਡਿਸਕਾਂ, ਅਤੇ ਨੈੱਟਵਰਕ ਸਰੋਤ।

ਅੱਗੇ ਕੀ ਹੈ?

• ਹੇਠ ਲਿਖੀਆਂ ਤਕਨੀਕਾਂ ਦੀ ਪੜਚੋਲ ਕਰੋ:

  1. ਡੌਕਰ
  2. ਕੰਟੇਨਰ
  3. ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ
  4. ਕਬਰਨੇਟਿਸ
  5. ਜੀ.ਕੇ.ਈ
  6. ਸੇਵਾ ਜਾਲ
  7. ਆਈਸਟੀਓ

• ਹੇਠਾਂ ਦਿੱਤੇ ਸਾਧਨਾਂ ਦੀ ਪੜਚੋਲ ਕਰੋ:

  1. ਕਲਾਊਡ SDK
  2. ਲਈ ਗਾਈਡ gcloud
  3. kubectl
  4. ਡੌਕਰ

• ਕੁਬਰਨੇਟਸ ਦੀਆਂ ਧਾਰਨਾਵਾਂ ਸਿੱਖੋ:

  1. ਕਲੱਸਟਰ
  2. ਨੋਡਸ
  3. ਫਲੀਆਂ
  4. ਸੇਵਾਵਾਂ
  5. ਤੈਨਾਤੀ

ਸਰੋਤ: www.habr.com