ਅਸੀਂ Yandex.Cloud ਵਿੱਚ 10 ਇਵੈਂਟਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੇ ਹਾਂ। ਭਾਗ 000

ਸਭ ਨੂੰ ਹੈਲੋ, ਦੋਸਤੋ!

* ਇਹ ਲੇਖ REBRAIN ਅਤੇ Yandex.Cloud ਓਪਨ ਵਰਕਸ਼ਾਪ 'ਤੇ ਅਧਾਰਤ ਹੈ, ਜੇਕਰ ਤੁਸੀਂ ਵੀਡੀਓ ਦੇਖਣਾ ਪਸੰਦ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਇਸ ਲਿੰਕ 'ਤੇ ਲੱਭ ਸਕਦੇ ਹੋ - https://youtu.be/cZLezUm0ekE

ਸਾਡੇ ਕੋਲ ਹਾਲ ਹੀ ਵਿੱਚ Yandex.Cloud ਲਾਈਵ ਅਜ਼ਮਾਉਣ ਦਾ ਮੌਕਾ ਸੀ। ਕਿਉਂਕਿ ਅਸੀਂ ਲੰਬੀ ਅਤੇ ਸਖ਼ਤ ਜਾਂਚ ਕਰਨਾ ਚਾਹੁੰਦੇ ਸੀ, ਅਸੀਂ ਤੁਰੰਤ ਇੱਕ ਕਲਾਉਡ ਬੇਸ ਦੇ ਨਾਲ ਇੱਕ ਸਧਾਰਨ ਵਰਡਪਰੈਸ ਬਲੌਗ ਲਾਂਚ ਕਰਨ ਦੇ ਵਿਚਾਰ ਨੂੰ ਛੱਡ ਦਿੱਤਾ - ਇਹ ਬਹੁਤ ਬੋਰਿੰਗ ਸੀ. ਕੁਝ ਸੋਚਣ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਨਜ਼ਦੀਕੀ ਰੀਅਲ ਟਾਈਮ ਮੋਡ ਵਿੱਚ ਘਟਨਾਵਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ ਇੱਕ ਉਤਪਾਦਨ ਸੇਵਾ ਆਰਕੀਟੈਕਚਰ ਦੇ ਸਮਾਨ ਕੁਝ ਤੈਨਾਤ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ।

ਮੈਨੂੰ ਪੂਰਾ ਯਕੀਨ ਹੈ ਕਿ ਬਹੁਤ ਸਾਰੇ ਔਨਲਾਈਨ (ਅਤੇ ਨਾ ਸਿਰਫ) ਕਾਰੋਬਾਰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਆਪਣੇ ਉਪਭੋਗਤਾਵਾਂ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਦਾ ਇੱਕ ਪਹਾੜ ਇਕੱਠਾ ਕਰਦੇ ਹਨ. ਘੱਟੋ-ਘੱਟ, ਇਹ ਕੁਝ ਖਾਸ ਫੈਸਲੇ ਲੈਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ - ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਔਨਲਾਈਨ ਗੇਮ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉਹਨਾਂ ਅੰਕੜਿਆਂ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹੋ ਜਿਸ ਪੱਧਰ 'ਤੇ ਉਪਭੋਗਤਾ ਅਕਸਰ ਫਸ ਜਾਂਦੇ ਹਨ ਅਤੇ ਤੁਹਾਡੇ ਖਿਡੌਣੇ ਨੂੰ ਮਿਟਾ ਦਿੰਦੇ ਹਨ। ਜਾਂ ਉਪਭੋਗਤਾ ਕੁਝ ਵੀ ਖਰੀਦੇ ਬਿਨਾਂ ਤੁਹਾਡੀ ਸਾਈਟ ਨੂੰ ਕਿਉਂ ਛੱਡ ਦਿੰਦੇ ਹਨ (ਹੈਲੋ, Yandex.Metrica).

ਇਸ ਲਈ, ਸਾਡੀ ਕਹਾਣੀ: ਅਸੀਂ ਗੋਲੰਗ ਵਿੱਚ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਕਿਵੇਂ ਲਿਖੀ, ਕਾਫਕਾ ਬਨਾਮ rabbitmq ਬਨਾਮ yqs ਦੀ ਜਾਂਚ ਕੀਤੀ, ਇੱਕ ਕਲਿਕਹਾਊਸ ਕਲੱਸਟਰ ਵਿੱਚ ਡੇਟਾ ਸਟ੍ਰੀਮਿੰਗ ਲਿਖੀ ਅਤੇ ਯੈਨਡੇਕਸ ਡੇਟਾਲੇਂਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੇਟਾ ਦੀ ਕਲਪਨਾ ਕੀਤੀ। ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਇਹ ਸਭ ਕੁਝ ਡੌਕਰ, ਟੈਰਾਫਾਰਮ, ਗਿਟਲਬ ਸੀਆਈ ਅਤੇ, ਬੇਸ਼ਕ, ਪ੍ਰੋਮੀਥੀਅਸ ਦੇ ਰੂਪ ਵਿੱਚ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਅਨੰਦ ਨਾਲ ਅਨੁਭਵ ਕੀਤਾ ਗਿਆ ਸੀ. ਚਲਾਂ ਚਲਦੇ ਹਾਂ!

ਮੈਂ ਤੁਰੰਤ ਇੱਕ ਰਿਜ਼ਰਵੇਸ਼ਨ ਕਰਨਾ ਚਾਹਾਂਗਾ ਕਿ ਅਸੀਂ ਇੱਕ ਬੈਠਕ ਵਿੱਚ ਹਰ ਚੀਜ਼ ਨੂੰ ਕੌਂਫਿਗਰ ਨਹੀਂ ਕਰ ਸਕਾਂਗੇ - ਇਸਦੇ ਲਈ ਸਾਨੂੰ ਲੜੀ ਵਿੱਚ ਕਈ ਲੇਖਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ. ਬਣਤਰ ਬਾਰੇ ਥੋੜਾ ਜਿਹਾ:

ਭਾਗ 1 (ਤੁਸੀਂ ਇਸਨੂੰ ਪੜ੍ਹ ਰਹੇ ਹੋ)। ਅਸੀਂ ਹੱਲ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਆਰਕੀਟੈਕਚਰ 'ਤੇ ਫੈਸਲਾ ਕਰਾਂਗੇ, ਅਤੇ ਗੋਲੰਗ ਵਿੱਚ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਵੀ ਲਿਖਾਂਗੇ।
ਭਾਗ 2। ਅਸੀਂ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਜਾਰੀ ਕਰਦੇ ਹਾਂ, ਇਸਨੂੰ ਸਕੇਲੇਬਲ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਲੋਡ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ।
ਭਾਗ 3। ਆਉ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਕਿ ਸਾਨੂੰ ਬਫਰ ਵਿੱਚ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ ਨਾ ਕਿ ਫਾਈਲਾਂ ਵਿੱਚ, ਅਤੇ ਕਾਫਕਾ, rabbitmq ਅਤੇ yandex ਕਤਾਰ ਸੇਵਾ ਦੀ ਤੁਲਨਾ ਵੀ ਕਰੀਏ।
ਭਾਗ 4 ਅਸੀਂ ਇੱਕ ਕਲਿਕਹਾਊਸ ਕਲੱਸਟਰ ਨੂੰ ਤੈਨਾਤ ਕਰਾਂਗੇ, ਉੱਥੇ ਬਫਰ ਤੋਂ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਇੱਕ ਸਟ੍ਰੀਮਿੰਗ ਸੇਵਾ ਲਿਖਾਂਗੇ, ਅਤੇ ਡੇਟਾਲੇਂਸ ਵਿੱਚ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਸਥਾਪਤ ਕਰਾਂਗੇ।
ਭਾਗ 5 ਆਉ ਪੂਰੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਸਹੀ ਰੂਪ ਵਿੱਚ ਲਿਆਈਏ - gitlab ci ਦੀ ਵਰਤੋਂ ਕਰਕੇ ci/cd ਸੈਟ ਅਪ ਕਰੋ, ਪ੍ਰੋਮੀਥੀਅਸ ਅਤੇ ਕੌਂਸਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਿਗਰਾਨੀ ਅਤੇ ਸੇਵਾ ਖੋਜ ਨੂੰ ਕਨੈਕਟ ਕਰੋ।

ਟੀ.ਕੇ

ਪਹਿਲਾਂ, ਆਓ ਸੰਦਰਭ ਦੀਆਂ ਸ਼ਰਤਾਂ ਨੂੰ ਤਿਆਰ ਕਰੀਏ - ਨਤੀਜੇ ਵਜੋਂ ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਕੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ।

1. ਅਸੀਂ Events.kis.im (kis.im ਇੱਕ ਟੈਸਟ ਡੋਮੇਨ ਹੈ ਜੋ ਅਸੀਂ ਸਾਰੇ ਲੇਖਾਂ ਵਿੱਚ ਵਰਤਾਂਗੇ) ਵਰਗਾ ਇੱਕ ਅੰਤਮ ਬਿੰਦੂ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਜਿਸ ਨੂੰ HTTPS ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਵੈਂਟਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
2. ਇਵੈਂਟ ਇੱਕ ਸਧਾਰਨ json ਹਨ ਜਿਵੇਂ: {“event”: “view”, “os”: “linux”, “browser”: “chrome”}। ਅੰਤਮ ਪੜਾਅ 'ਤੇ ਅਸੀਂ ਥੋੜੇ ਹੋਰ ਖੇਤਰਾਂ ਨੂੰ ਜੋੜਾਂਗੇ, ਪਰ ਇਹ ਕੋਈ ਵੱਡੀ ਭੂਮਿਕਾ ਨਹੀਂ ਨਿਭਾਏਗਾ. ਜੇਕਰ ਤੁਸੀਂ ਚਾਹੋ, ਤਾਂ ਤੁਸੀਂ ਪ੍ਰੋਟੋਬੁਫ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।
3. ਸੇਵਾ ਪ੍ਰਤੀ ਸਕਿੰਟ 10 ਇਵੈਂਟਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
4. ਸਾਡੇ ਹੱਲ ਵਿੱਚ ਸਿਰਫ਼ ਨਵੀਆਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਜੋੜ ਕੇ ਖਿਤਿਜੀ ਤੌਰ 'ਤੇ ਸਕੇਲ ਕਰਨਾ ਸੰਭਵ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਤੇ ਇਹ ਚੰਗਾ ਹੋਵੇਗਾ ਜੇਕਰ ਅਸੀਂ ਕਲਾਇੰਟ ਦੀਆਂ ਬੇਨਤੀਆਂ ਲਈ ਲੇਟੈਂਸੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਅਗਲੇ ਹਿੱਸੇ ਨੂੰ ਵੱਖ-ਵੱਖ ਭੂ-ਸਥਾਨਾਂ 'ਤੇ ਲਿਜਾ ਸਕਦੇ ਹਾਂ।
5. ਨੁਕਸ ਸਹਿਣਸ਼ੀਲਤਾ. ਹੱਲ ਕਾਫ਼ੀ ਸਥਿਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਕਿਸੇ ਵੀ ਹਿੱਸੇ ਦੇ ਡਿੱਗਣ ਤੋਂ ਬਚਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (ਇੱਕ ਨਿਸ਼ਚਿਤ ਸੰਖਿਆ ਤੱਕ, ਬੇਸ਼ਕ)।

ਆਰਕੀਟੈਕਚਰ

ਆਮ ਤੌਰ 'ਤੇ, ਇਸ ਕਿਸਮ ਦੇ ਕੰਮ ਲਈ, ਕਲਾਸੀਕਲ ਆਰਕੀਟੈਕਚਰ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਖੋਜੇ ਗਏ ਹਨ ਜੋ ਕੁਸ਼ਲ ਸਕੇਲਿੰਗ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ। ਚਿੱਤਰ ਸਾਡੇ ਹੱਲ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਦਿਖਾਉਂਦਾ ਹੈ।

ਇਸ ਲਈ ਸਾਡੇ ਕੋਲ ਕੀ ਹੈ:

1. ਖੱਬੇ ਪਾਸੇ ਸਾਡੀਆਂ ਡਿਵਾਈਸਾਂ ਹਨ ਜੋ ਵੱਖ-ਵੱਖ ਇਵੈਂਟਾਂ ਨੂੰ ਉਤਪੰਨ ਕਰਦੀਆਂ ਹਨ, ਭਾਵੇਂ ਇਹ ਖਿਡਾਰੀ ਇੱਕ ਸਮਾਰਟਫੋਨ 'ਤੇ ਇੱਕ ਖਿਡੌਣੇ ਵਿੱਚ ਇੱਕ ਪੱਧਰ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ ਜਾਂ ਇੱਕ ਨਿਯਮਤ ਬ੍ਰਾਊਜ਼ਰ ਰਾਹੀਂ ਇੱਕ ਔਨਲਾਈਨ ਸਟੋਰ ਵਿੱਚ ਆਰਡਰ ਬਣਾਉਣਾ ਹੈ। ਇੱਕ ਇਵੈਂਟ, ਜਿਵੇਂ ਕਿ ਨਿਰਧਾਰਨ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, ਇੱਕ ਸਧਾਰਨ json ਹੈ ਜੋ ਸਾਡੇ ਅੰਤਮ ਬਿੰਦੂ - events.kis.im 'ਤੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ।

2. ਪਹਿਲੇ ਦੋ ਸਰਵਰ ਸਧਾਰਨ ਬੈਲੈਂਸਰ ਹਨ, ਉਹਨਾਂ ਦੇ ਮੁੱਖ ਕੰਮ ਹਨ:

• ਲਗਾਤਾਰ ਉਪਲਬਧ ਰਹੋ. ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, Keepalived, ਜੋ ਸਮੱਸਿਆਵਾਂ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਨੋਡਾਂ ਵਿਚਕਾਰ ਵਰਚੁਅਲ IP ਨੂੰ ਬਦਲ ਦੇਵੇਗਾ।
• TLS ਨੂੰ ਸਮਾਪਤ ਕਰੋ। ਹਾਂ, ਅਸੀਂ ਉਹਨਾਂ 'ਤੇ TLS ਨੂੰ ਖਤਮ ਕਰ ਦੇਵਾਂਗੇ। ਪਹਿਲਾਂ, ਤਾਂ ਕਿ ਸਾਡਾ ਹੱਲ ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪਾਲਣਾ ਕਰੇ, ਅਤੇ ਦੂਜਾ, ਸਾਡੇ ਬੈਕਐਂਡ ਸਰਵਰਾਂ ਤੋਂ ਇੱਕ ਇਨਕ੍ਰਿਪਟਡ ਕੁਨੈਕਸ਼ਨ ਸਥਾਪਤ ਕਰਨ ਦੇ ਬੋਝ ਤੋਂ ਰਾਹਤ ਪਾਉਣ ਲਈ।
• ਉਪਲਬਧ ਬੈਕਐਂਡ ਸਰਵਰਾਂ ਲਈ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਤੁਲਿਤ ਕਰੋ। ਇੱਥੇ ਮੁੱਖ ਸ਼ਬਦ ਪਹੁੰਚਯੋਗ ਹੈ. ਇਸ ਦੇ ਆਧਾਰ 'ਤੇ, ਅਸੀਂ ਇਹ ਸਮਝਦੇ ਹਾਂ ਕਿ ਲੋਡ ਬੈਲੇਂਸਰਾਂ ਨੂੰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਨਾਲ ਸਾਡੇ ਸਰਵਰਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਅਸਫਲ ਨੋਡਾਂ ਲਈ ਟ੍ਰੈਫਿਕ ਨੂੰ ਸੰਤੁਲਿਤ ਕਰਨਾ ਬੰਦ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

3. ਬੈਲੇਂਸਰਾਂ ਤੋਂ ਬਾਅਦ, ਸਾਡੇ ਕੋਲ ਐਪਲੀਕੇਸ਼ਨ ਸਰਵਰ ਹਨ ਜੋ ਕਾਫ਼ੀ ਸਧਾਰਨ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾ ਰਹੇ ਹਨ। ਇਹ HTTP ਦੁਆਰਾ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਭੇਜੇ ਗਏ json ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ ਅਤੇ ਡੇਟਾ ਨੂੰ ਇੱਕ ਬਫਰ ਵਿੱਚ ਪਾਉਣਾ ਚਾਹੀਦਾ ਹੈ।

4. ਚਿੱਤਰ ਕਾਫਕਾ ਨੂੰ ਇੱਕ ਬਫਰ ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾਉਂਦਾ ਹੈ, ਹਾਲਾਂਕਿ, ਬੇਸ਼ੱਕ, ਇਸ ਪੱਧਰ 'ਤੇ ਹੋਰ ਸਮਾਨ ਸੇਵਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਅਸੀਂ ਤੀਜੇ ਲੇਖ ਵਿੱਚ ਕਾਫਕਾ, rabbitmq ਅਤੇ yqs ਦੀ ਤੁਲਨਾ ਕਰਾਂਗੇ।

5. ਸਾਡੇ ਆਰਕੀਟੈਕਚਰ ਦਾ ਅੰਤਮ ਬਿੰਦੂ ਕਲਿਕਹਾਊਸ ਹੈ - ਇੱਕ ਕਾਲਮ ਡੇਟਾਬੇਸ ਜੋ ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇਸ ਪੱਧਰ 'ਤੇ, ਸਾਨੂੰ ਬਫਰ ਤੋਂ ਸਟੋਰੇਜ ਸਿਸਟਮ ਵਿੱਚ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ (ਇਸ ਬਾਰੇ ਲੇਖ 4 ਵਿੱਚ ਹੋਰ)।

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

ਤਰੀਕੇ ਨਾਲ, ਜੇਕਰ ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਭੂ-ਸਥਾਨਾਂ ਵਿੱਚ ਸਾਡੀਆਂ ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਸਕੇਲ ਦੇ ਵਿਕਲਪਿਕ ਹਿੱਸੇ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਸ ਤੋਂ ਆਸਾਨ ਕੁਝ ਵੀ ਨਹੀਂ ਹੈ:

ਹਰੇਕ ਭੂ-ਸਥਾਨ ਵਿੱਚ ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਕਾਫਕਾ ਦੇ ਨਾਲ ਇੱਕ ਲੋਡ ਬੈਲੇਂਸਰ ਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਹਾਂ। ਆਮ ਤੌਰ 'ਤੇ, 2 ਐਪਲੀਕੇਸ਼ਨ ਸਰਵਰ, 3 ਕਾਫਕਾ ਨੋਡਸ ਅਤੇ ਇੱਕ ਕਲਾਉਡ ਬੈਲੇਂਸਰ, ਉਦਾਹਰਨ ਲਈ, ਕਲਾਉਡਫਲੇਅਰ, ਕਾਫ਼ੀ ਹਨ, ਜੋ ਕਿ ਕਲਾਇੰਟ ਦੇ ਸਰੋਤ IP ਪਤੇ ਦੇ ਅਧਾਰ 'ਤੇ ਭੂ-ਸਥਾਨ ਦੁਆਰਾ ਐਪਲੀਕੇਸ਼ਨ ਨੋਡਾਂ ਅਤੇ ਸੰਤੁਲਨ ਬੇਨਤੀਆਂ ਦੀ ਉਪਲਬਧਤਾ ਦੀ ਜਾਂਚ ਕਰਨਗੇ। ਇਸ ਤਰ੍ਹਾਂ, ਇੱਕ ਅਮਰੀਕੀ ਕਲਾਇੰਟ ਦੁਆਰਾ ਭੇਜਿਆ ਗਿਆ ਡੇਟਾ ਅਮਰੀਕੀ ਸਰਵਰਾਂ 'ਤੇ ਉਤਰੇਗਾ। ਅਤੇ ਅਫਰੀਕਾ ਤੋਂ ਡੇਟਾ ਅਫਰੀਕਨ ਵਿੱਚ ਹੈ।

ਫਿਰ ਸਭ ਕੁਝ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ - ਅਸੀਂ ਕਾਫਕਾ ਸੈੱਟ ਤੋਂ ਮਿਰਰ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਸਾਰੇ ਸਥਾਨਾਂ ਤੋਂ ਸਾਰੇ ਡੇਟਾ ਨੂੰ ਰੂਸ ਵਿੱਚ ਸਥਿਤ ਸਾਡੇ ਕੇਂਦਰੀ ਡੇਟਾ ਸੈਂਟਰ ਵਿੱਚ ਕਾਪੀ ਕਰਦੇ ਹਾਂ. ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਡੇਟਾ ਨੂੰ ਪਾਰਸ ਕਰਦੇ ਹਾਂ ਅਤੇ ਅਗਲੀ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਲਈ ਇਸਨੂੰ ਕਲਿਕਹਾਊਸ ਵਿੱਚ ਰਿਕਾਰਡ ਕਰਦੇ ਹਾਂ।

ਇਸ ਲਈ, ਅਸੀਂ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਹੈ - ਆਓ Yandex.Cloud ਨੂੰ ਹਿੱਲਣਾ ਸ਼ੁਰੂ ਕਰੀਏ!

ਇੱਕ ਅਰਜ਼ੀ ਲਿਖਣਾ

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

ਇੱਕ ਘੰਟਾ (ਸ਼ਾਇਦ ਦੋ ਘੰਟੇ) ਬਿਤਾਉਣ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਕੁਝ ਅਜਿਹਾ ਮਿਲਦਾ ਹੈ: https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/main.go.

ਮੈਂ ਇੱਥੇ ਮੁੱਖ ਨੁਕਤੇ ਕੀ ਨੋਟ ਕਰਨਾ ਚਾਹਾਂਗਾ:

1. ਐਪਲੀਕੇਸ਼ਨ ਸ਼ੁਰੂ ਕਰਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਦੋ ਫਲੈਗ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਕ ਉਸ ਪੋਰਟ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ ਜਿਸ 'ਤੇ ਅਸੀਂ ਆਉਣ ਵਾਲੀਆਂ http ਬੇਨਤੀਆਂ (-addr) ਨੂੰ ਸੁਣਾਂਗੇ। ਦੂਜਾ ਕਾਫਕਾ ਸਰਵਰ ਪਤੇ ਲਈ ਹੈ ਜਿੱਥੇ ਅਸੀਂ ਆਪਣੀਆਂ ਘਟਨਾਵਾਂ ਨੂੰ ਰਿਕਾਰਡ ਕਰਾਂਗੇ (-ਕਾਫਕਾ):

addr     = flag.String("addr", ":8080", "TCP address to listen to")
kafka    = flag.String("kafka", "127.0.0.1:9092", "Kafka endpoints”)

2. ਐਪਲੀਕੇਸ਼ਨ ਸਰਮਾ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ([] github.com/Shopify/sarama) ਕਾਫਕਾ ਕਲੱਸਟਰ ਨੂੰ ਸੁਨੇਹੇ ਭੇਜਣ ਲਈ। ਅਸੀਂ ਤੁਰੰਤ ਅਧਿਕਤਮ ਪ੍ਰੋਸੈਸਿੰਗ ਸਪੀਡ ਦੇ ਉਦੇਸ਼ ਨਾਲ ਸੈਟਿੰਗਾਂ ਸੈਟ ਕਰਦੇ ਹਾਂ:

config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForLocal
config.Producer.Compression = sarama.CompressionSnappy
config.Producer.Return.Successes = true

3. ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਬਿਲਟ-ਇਨ ਪ੍ਰੋਮੀਥੀਅਸ ਕਲਾਇੰਟ ਵੀ ਹੈ, ਜੋ ਵੱਖ-ਵੱਖ ਮੈਟ੍ਰਿਕਸ ਇਕੱਤਰ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ:

• ਸਾਡੀ ਅਰਜ਼ੀ ਲਈ ਬੇਨਤੀਆਂ ਦੀ ਗਿਣਤੀ;
• ਬੇਨਤੀ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵੇਲੇ ਗਲਤੀਆਂ ਦੀ ਗਿਣਤੀ (ਪੋਸਟ ਬੇਨਤੀ ਨੂੰ ਪੜ੍ਹਨਾ ਅਸੰਭਵ, ਟੁੱਟੇ ਜੇਸਨ, ਕਾਫਕਾ ਨੂੰ ਲਿਖਣਾ ਅਸੰਭਵ);
• ਕਲਾਇੰਟ ਤੋਂ ਇੱਕ ਬੇਨਤੀ ਲਈ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦਾ ਸਮਾਂ, ਕਾਫਕਾ ਨੂੰ ਸੁਨੇਹਾ ਲਿਖਣ ਦਾ ਸਮਾਂ ਵੀ ਸ਼ਾਮਲ ਹੈ।

4. ਤਿੰਨ ਅੰਤਮ ਬਿੰਦੂ ਜੋ ਸਾਡੀ ਅਰਜ਼ੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦੇ ਹਨ:

• /status - ਇਹ ਦਿਖਾਉਣ ਲਈ ਠੀਕ ਹੈ ਕਿ ਅਸੀਂ ਜ਼ਿੰਦਾ ਹਾਂ। ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਕੁਝ ਚੈਕ ਜੋੜ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਕਾਫਕਾ ਕਲੱਸਟਰ ਦੀ ਉਪਲਬਧਤਾ।
• /ਮੈਟ੍ਰਿਕਸ - ਇਸ url ਦੇ ਅਨੁਸਾਰ, ਪ੍ਰੋਮੀਥੀਅਸ ਕਲਾਇੰਟ ਉਸ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਵਾਪਸ ਕਰੇਗਾ ਜੋ ਇਸਨੇ ਇਕੱਤਰ ਕੀਤੇ ਹਨ।
• /post ਮੁੱਖ ਅੰਤਮ ਬਿੰਦੂ ਹੈ ਜਿੱਥੇ json ਦੇ ਅੰਦਰ POST ਬੇਨਤੀਆਂ ਭੇਜੀਆਂ ਜਾਣਗੀਆਂ। ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਵੈਧਤਾ ਲਈ json ਦੀ ਜਾਂਚ ਕਰਦੀ ਹੈ ਅਤੇ ਜੇਕਰ ਸਭ ਕੁਝ ਠੀਕ ਹੈ, ਤਾਂ ਇਹ ਕਾਫਕਾ ਕਲੱਸਟਰ ਨੂੰ ਡੇਟਾ ਲਿਖਦਾ ਹੈ।

ਮੈਂ ਇੱਕ ਰਿਜ਼ਰਵੇਸ਼ਨ ਕਰਾਂਗਾ ਕਿ ਕੋਡ ਸੰਪੂਰਨ ਨਹੀਂ ਹੈ - ਇਹ ਪੂਰਾ ਹੋ ਸਕਦਾ ਹੈ (ਅਤੇ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ!) ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਬਿਲਟ-ਇਨ ਨੈੱਟ/http ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬੰਦ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਤੇਜ਼ ਤੇਜ਼ HTTP 'ਤੇ ਸਵਿਚ ਕਰ ਸਕਦੇ ਹੋ। ਜਾਂ ਤੁਸੀਂ json ਵੈਧਤਾ ਜਾਂਚ ਨੂੰ ਬਾਅਦ ਦੇ ਪੜਾਅ 'ਤੇ ਲਿਜਾ ਕੇ ਪ੍ਰੋਸੈਸਿੰਗ ਸਮਾਂ ਅਤੇ cpu ਸਰੋਤ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ - ਜਦੋਂ ਡੇਟਾ ਨੂੰ ਬਫਰ ਤੋਂ ਕਲਿੱਕਹਾਊਸ ਕਲੱਸਟਰ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਮੁੱਦੇ ਦੇ ਵਿਕਾਸ ਪੱਖ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਤੁਰੰਤ ਆਪਣੇ ਭਵਿੱਖ ਦੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਬਾਰੇ ਸੋਚਿਆ ਅਤੇ ਡੌਕਰ ਦੁਆਰਾ ਸਾਡੀ ਅਰਜ਼ੀ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ। ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਅੰਤਮ ਡੌਕਰਫਾਈਲ ਹੈ https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/Dockerfile. ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ, ਇਕੋ ਇਕ ਬਿੰਦੂ ਜਿਸ ਵੱਲ ਮੈਂ ਧਿਆਨ ਦੇਣਾ ਚਾਹਾਂਗਾ ਉਹ ਹੈ ਮਲਟੀਸਟੇਜ ਅਸੈਂਬਲੀ, ਜੋ ਸਾਨੂੰ ਸਾਡੇ ਕੰਟੇਨਰ ਦੇ ਅੰਤਮ ਚਿੱਤਰ ਨੂੰ ਘਟਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ.

ਬੱਦਲ ਵਿੱਚ ਪਹਿਲੇ ਕਦਮ

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

ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਡੇ ਲਈ ਇੱਕ ਵੱਖਰਾ ਕਲਾਉਡ ਅਤੇ ਇੱਕ ਡਿਫੌਲਟ ਡਾਇਰੈਕਟਰੀ ਬਣਾਈ ਜਾਵੇਗੀ, ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਕਲਾਉਡ ਸਰੋਤ ਬਣਾਉਣਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ। ਆਮ ਤੌਰ 'ਤੇ, Yandex.Cloud ਵਿੱਚ, ਸਰੋਤਾਂ ਦਾ ਸਬੰਧ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

ਤੁਸੀਂ ਇੱਕ ਖਾਤੇ ਲਈ ਕਈ ਕਲਾਊਡ ਬਣਾ ਸਕਦੇ ਹੋ। ਅਤੇ ਕਲਾਉਡ ਦੇ ਅੰਦਰ, ਵੱਖ-ਵੱਖ ਕੰਪਨੀ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਵੱਖ-ਵੱਖ ਡਾਇਰੈਕਟਰੀਆਂ ਬਣਾਓ। ਤੁਸੀਂ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਇਸ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹ ਸਕਦੇ ਹੋ - https://cloud.yandex.ru/docs/resource-manager/concepts/resources-hierarchy. ਤਰੀਕੇ ਨਾਲ, ਮੈਂ ਅਕਸਰ ਟੈਕਸਟ ਵਿੱਚ ਹੇਠਾਂ ਇਸਦਾ ਹਵਾਲਾ ਦੇਵਾਂਗਾ. ਜਦੋਂ ਮੈਂ ਸ਼ੁਰੂ ਤੋਂ ਪੂਰਾ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਸਥਾਪਤ ਕੀਤਾ, ਤਾਂ ਦਸਤਾਵੇਜ਼ਾਂ ਨੇ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ ਮੇਰੀ ਮਦਦ ਕੀਤੀ, ਇਸ ਲਈ ਮੈਂ ਤੁਹਾਨੂੰ ਇਸਦਾ ਅਧਿਐਨ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੰਦਾ ਹਾਂ।

ਕਲਾਉਡ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਵੈੱਬ ਇੰਟਰਫੇਸ ਅਤੇ ਕੰਸੋਲ ਉਪਯੋਗਤਾ - yc ਦੋਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ. ਇੰਸਟਾਲੇਸ਼ਨ ਇੱਕ ਕਮਾਂਡ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ (ਲੀਨਕਸ ਅਤੇ ਮੈਕ ਓਐਸ ਲਈ):

curl https://storage.yandexcloud.net/yandexcloud-yc/install.sh | bash

ਜੇਕਰ ਤੁਹਾਡਾ ਅੰਦਰੂਨੀ ਸੁਰੱਖਿਆ ਮਾਹਰ ਇੰਟਰਨੈੱਟ ਤੋਂ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਣ ਬਾਰੇ ਗੁੱਸਾ ਕਰ ਰਿਹਾ ਹੈ, ਤਾਂ, ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਨੂੰ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਪੜ੍ਹ ਸਕਦੇ ਹੋ, ਅਤੇ ਦੂਜਾ, ਅਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਉਪਭੋਗਤਾ ਦੇ ਅਧੀਨ - ਬਿਨਾਂ ਰੂਟ ਅਧਿਕਾਰਾਂ ਦੇ ਚਲਾਉਂਦੇ ਹਾਂ।

ਜੇਕਰ ਤੁਸੀਂ ਵਿੰਡੋਜ਼ ਲਈ ਇੱਕ ਕਲਾਇੰਟ ਸਥਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਇੱਥੇ ਅਤੇ ਫਿਰ ਚਲਾਓ yc initਇਸ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਨੁਕੂਲਿਤ ਕਰਨ ਲਈ:

vozerov@mba:~ $ yc init
Welcome! This command will take you through the configuration process.
Please go to https://oauth.yandex.ru/authorize?response_type=token&client_id= in order to obtain OAuth token.

Please enter OAuth token:
Please select cloud to use:
 [1] cloud-b1gv67ihgfu3bp (id = b1gv67ihgfu3bpt24o0q)
 [2] fevlake-cloud (id = b1g6bvup3toribomnh30)
Please enter your numeric choice: 2
Your current cloud has been set to 'fevlake-cloud' (id = b1g6bvup3toribomnh30).
Please choose folder to use:
 [1] default (id = b1g5r6h11knotfr8vjp7)
 [2] Create a new folder
Please enter your numeric choice: 1
Your current folder has been set to 'default' (id = b1g5r6h11knotfr8vjp7).
Do you want to configure a default Compute zone? [Y/n]
Which zone do you want to use as a profile default?
 [1] ru-central1-a
 [2] ru-central1-b
 [3] ru-central1-c
 [4] Don't set default zone
Please enter your numeric choice: 1
Your profile default Compute zone has been set to 'ru-central1-a'.
vozerov@mba:~ $

ਸਿਧਾਂਤ ਵਿੱਚ, ਪ੍ਰਕਿਰਿਆ ਸਧਾਰਨ ਹੈ - ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ ਕਲਾਉਡ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਇੱਕ ਓਥ ਟੋਕਨ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਕਲਾਉਡ ਅਤੇ ਫੋਲਡਰ ਦੀ ਚੋਣ ਕਰੋ ਜੋ ਤੁਸੀਂ ਵਰਤੋਗੇ।

ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕੋ ਕਲਾਊਡ ਦੇ ਅੰਦਰ ਕਈ ਖਾਤੇ ਜਾਂ ਫੋਲਡਰ ਹਨ, ਤਾਂ ਤੁਸੀਂ yc ਕੌਂਫਿਗ ਪ੍ਰੋਫਾਈਲ ਬਣਾਓ ਅਤੇ ਉਹਨਾਂ ਵਿਚਕਾਰ ਸਵਿਚ ਕਰਕੇ ਵੱਖਰੀਆਂ ਸੈਟਿੰਗਾਂ ਦੇ ਨਾਲ ਵਾਧੂ ਪ੍ਰੋਫਾਈਲ ਬਣਾ ਸਕਦੇ ਹੋ।

ਉਪਰੋਕਤ ਤਰੀਕਿਆਂ ਤੋਂ ਇਲਾਵਾ, Yandex.Cloud ਟੀਮ ਨੇ ਬਹੁਤ ਵਧੀਆ ਲਿਖਿਆ ਟੈਰਾਫਾਰਮ ਲਈ ਪਲੱਗਇਨ ਕਲਾਉਡ ਸਰੋਤਾਂ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ। ਮੇਰੇ ਹਿੱਸੇ ਲਈ, ਮੈਂ ਇੱਕ ਗਿੱਟ ਰਿਪੋਜ਼ਟਰੀ ਤਿਆਰ ਕੀਤੀ, ਜਿੱਥੇ ਮੈਂ ਉਹਨਾਂ ਸਾਰੇ ਸਰੋਤਾਂ ਦਾ ਵਰਣਨ ਕੀਤਾ ਜੋ ਲੇਖ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਬਣਾਏ ਜਾਣਗੇ - https://github.com/rebrainme/yandex-cloud-events/. ਅਸੀਂ ਮਾਸਟਰ ਬ੍ਰਾਂਚ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ, ਆਓ ਇਸਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਕਲੋਨ ਕਰੀਏ:

vozerov@mba:~ $ git clone https://github.com/rebrainme/yandex-cloud-events/ events
Cloning into 'events'...
remote: Enumerating objects: 100, done.
remote: Counting objects: 100% (100/100), done.
remote: Compressing objects: 100% (68/68), done.
remote: Total 100 (delta 37), reused 89 (delta 26), pack-reused 0
Receiving objects: 100% (100/100), 25.65 KiB | 168.00 KiB/s, done.
Resolving deltas: 100% (37/37), done.
vozerov@mba:~ $ cd events/terraform/

ਟੈਰਾਫਾਰਮ ਵਿੱਚ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਸਾਰੇ ਮੁੱਖ ਵੇਰੀਏਬਲ main.tf ਫਾਈਲ ਵਿੱਚ ਲਿਖੇ ਗਏ ਹਨ। ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੀ ਸਮੱਗਰੀ ਦੇ ਨਾਲ ਟੈਰਾਫਾਰਮ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ ਪ੍ਰਾਈਵੇਟ.auto.tfvars ਫਾਈਲ ਬਣਾਓ:

# Yandex Cloud Oauth token
yc_token = ""
# Yandex Cloud ID
yc_cloud_id = ""
# Yandex Cloud folder ID
yc_folder_id = ""
# Default Yandex Cloud Region
yc_region = "ru-central1-a"
# Cloudflare email
cf_email = ""
# Cloudflare token
cf_token = ""
# Cloudflare zone id
cf_zone_id = ""

ਸਾਰੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ yc ਸੰਰਚਨਾ ਸੂਚੀ ਤੋਂ ਲਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਕਿਉਂਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕੰਸੋਲ ਉਪਯੋਗਤਾ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰ ਚੁੱਕੇ ਹਾਂ। ਮੈਂ ਤੁਹਾਨੂੰ ਤੁਰੰਤ ਪ੍ਰਾਈਵੇਟ.auto.tfvars ਨੂੰ .gitignore ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੰਦਾ ਹਾਂ, ਤਾਂ ਜੋ ਗਲਤੀ ਨਾਲ ਨਿੱਜੀ ਡੇਟਾ ਪ੍ਰਕਾਸ਼ਿਤ ਨਾ ਹੋ ਸਕੇ।

ਪ੍ਰਾਈਵੇਟ.auto.tfvars ਵਿੱਚ ਅਸੀਂ Cloudflare ਤੋਂ ਡਾਟਾ ਵੀ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਹੈ - DNS ਰਿਕਾਰਡ ਬਣਾਉਣ ਅਤੇ ਮੁੱਖ ਡੋਮੇਨ events.kis.im ਨੂੰ ਸਾਡੇ ਸਰਵਰਾਂ 'ਤੇ ਪ੍ਰੌਕਸੀ ਕਰਨ ਲਈ। ਜੇਕਰ ਤੁਸੀਂ ਕਲਾਉਡਫਲੇਅਰ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ main.tf ਅਤੇ dns.tf ਫਾਈਲ ਵਿੱਚ ਕਲਾਉਡਫਲੇਅਰ ਪ੍ਰਦਾਤਾ ਦੀ ਸ਼ੁਰੂਆਤ ਨੂੰ ਹਟਾ ਦਿਓ, ਜੋ ਕਿ ਲੋੜੀਂਦੇ dns ਰਿਕਾਰਡ ਬਣਾਉਣ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ।

ਸਾਡੇ ਕੰਮ ਵਿੱਚ ਅਸੀਂ ਸਾਰੇ ਤਿੰਨ ਤਰੀਕਿਆਂ ਨੂੰ ਜੋੜਾਂਗੇ - ਵੈੱਬ ਇੰਟਰਫੇਸ, ਕੰਸੋਲ ਉਪਯੋਗਤਾ, ਅਤੇ ਟੈਰਾਫਾਰਮ।

ਵਰਚੁਅਲ ਨੈੱਟਵਰਕ

ਇਮਾਨਦਾਰ ਹੋਣ ਲਈ, ਤੁਸੀਂ ਇਸ ਪੜਾਅ ਨੂੰ ਛੱਡ ਸਕਦੇ ਹੋ, ਕਿਉਂਕਿ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ ਕਲਾਊਡ ਬਣਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਆਪਣੇ ਆਪ ਹੀ ਇੱਕ ਵੱਖਰਾ ਨੈੱਟਵਰਕ ਅਤੇ 3 ਸਬਨੈੱਟ ਬਣਾਏ ਜਾਣਗੇ - ਹਰੇਕ ਉਪਲਬਧਤਾ ਜ਼ੋਨ ਲਈ ਇੱਕ। ਪਰ ਅਸੀਂ ਫਿਰ ਵੀ ਆਪਣੇ ਪਤੇ ਦੇ ਨਾਲ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਲਈ ਇੱਕ ਵੱਖਰਾ ਨੈੱਟਵਰਕ ਬਣਾਉਣਾ ਚਾਹਾਂਗੇ। Yandex.Cloud ਵਿੱਚ ਨੈੱਟਵਰਕ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਦਾ ਆਮ ਚਿੱਤਰ ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ (ਇਮਾਨਦਾਰੀ ਨਾਲ ਇਸ ਤੋਂ ਲਿਆ ਗਿਆ ਹੈ https://cloud.yandex.ru/docs/vpc/concepts/)

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

ਨੈੱਟਵਰਕ ਬਣਾਉਣ ਦਾ ਵਰਣਨ ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ network.tf ਫਾਈਲ ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਹੈ। ਉੱਥੇ ਅਸੀਂ ਇੱਕ ਆਮ ਪ੍ਰਾਈਵੇਟ ਨੈੱਟਵਰਕ ਅੰਦਰੂਨੀ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਵੱਖ-ਵੱਖ ਉਪਲਬਧਤਾ ਜ਼ੋਨਾਂ ਵਿੱਚ ਇਸ ਨਾਲ ਤਿੰਨ ਸਬਨੈੱਟ ਜੋੜਦੇ ਹਾਂ - ਅੰਦਰੂਨੀ-ਏ (172.16.1.0/24), ਅੰਦਰੂਨੀ-ਬੀ (172.16.2.0/24), ਅੰਦਰੂਨੀ-ਸੀ (172.16.3.0/24) ).

ਟੈਰਾਫਾਰਮ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਨੈੱਟਵਰਕ ਬਣਾਓ:

vozerov@mba:~/events/terraform (master) $ terraform init
... skipped ..

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_vpc_subnet.internal-a -target yandex_vpc_subnet.internal-b -target yandex_vpc_subnet.internal-c

... skipped ...

Plan: 4 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

yandex_vpc_network.internal: Creating...
yandex_vpc_network.internal: Creation complete after 3s [id=enp2g2rhile7gbqlbrkr]
yandex_vpc_subnet.internal-a: Creating...
yandex_vpc_subnet.internal-b: Creating...
yandex_vpc_subnet.internal-c: Creating...
yandex_vpc_subnet.internal-a: Creation complete after 6s [id=e9b1dad6mgoj2v4funog]
yandex_vpc_subnet.internal-b: Creation complete after 7s [id=e2liv5i4amu52p64ac9p]
yandex_vpc_subnet.internal-c: Still creating... [10s elapsed]
yandex_vpc_subnet.internal-c: Creation complete after 10s [id=b0c2qhsj2vranoc9vhcq]

Apply complete! Resources: 4 added, 0 changed, 0 destroyed.

ਬਹੁਤ ਵਧੀਆ! ਅਸੀਂ ਆਪਣਾ ਨੈੱਟਵਰਕ ਬਣਾਇਆ ਹੈ ਅਤੇ ਹੁਣ ਸਾਡੀਆਂ ਅੰਦਰੂਨੀ ਸੇਵਾਵਾਂ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਹਾਂ।

ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਬਣਾਉਣਾ

ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਸਿਰਫ ਦੋ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ - ਸਾਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਅਤੇ ਚਲਾਉਣ ਲਈ ਪਹਿਲੀ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ, ਦੂਜੀ ਕਾਫਕਾ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਜਿਸਦੀ ਵਰਤੋਂ ਅਸੀਂ ਆਉਣ ਵਾਲੇ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਕਰਾਂਗੇ। ਅਤੇ ਅਸੀਂ ਇੱਕ ਹੋਰ ਮਸ਼ੀਨ ਬਣਾਵਾਂਗੇ ਜਿੱਥੇ ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਪ੍ਰੋਮੀਥੀਅਸ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਾਂਗੇ।

ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਨੂੰ ਜਵਾਬਦੇਹੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾਵੇਗਾ, ਇਸ ਲਈ ਟੈਰਾਫਾਰਮ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਜਵਾਬਦੇਹ ਦੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਅਤੇ ਜਵਾਬਦੇਹ ਗਲੈਕਸੀ ਦੇ ਨਾਲ ਲੋੜੀਂਦੀਆਂ ਭੂਮਿਕਾਵਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ:

vozerov@mba:~/events/terraform (master) $ cd ../ansible/
vozerov@mba:~/events/ansible (master) $ ansible-galaxy install -r requirements.yml
- cloudalchemy-prometheus (master) is already installed, skipping.
- cloudalchemy-grafana (master) is already installed, skipping.
- sansible.kafka (master) is already installed, skipping.
- sansible.zookeeper (master) is already installed, skipping.
- geerlingguy.docker (master) is already installed, skipping.
vozerov@mba:~/events/ansible (master) $

ਜਵਾਬਦੇਹ ਫੋਲਡਰ ਦੇ ਅੰਦਰ ਇੱਕ ਉਦਾਹਰਨ .ansible.cfg ਕੌਂਫਿਗਰੇਸ਼ਨ ਫਾਈਲ ਹੈ ਜੋ ਮੈਂ ਵਰਤਦਾ ਹਾਂ। ਇਹ ਕੰਮ ਆ ਸਕਦਾ ਹੈ।

ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ssh-agent ਚੱਲ ਰਿਹਾ ਹੈ ਅਤੇ ਇੱਕ ssh ਕੁੰਜੀ ਜੋੜੀ ਗਈ ਹੈ, ਨਹੀਂ ਤਾਂ ਟੈਰਾਫਾਰਮ ਬਣਾਈਆਂ ਗਈਆਂ ਮਸ਼ੀਨਾਂ ਨਾਲ ਜੁੜਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੇਗਾ। ਮੈਨੂੰ, ਬੇਸ਼ਕ, os x ਵਿੱਚ ਇੱਕ ਬੱਗ ਮਿਲਿਆ: https://github.com/ansible/ansible/issues/32499#issuecomment-341578864. ਇਸ ਨੂੰ ਦੁਬਾਰਾ ਵਾਪਰਨ ਤੋਂ ਰੋਕਣ ਲਈ, Terraform ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ env ਵਿੱਚ ਇੱਕ ਛੋਟਾ ਵੇਰੀਏਬਲ ਜੋੜੋ:

vozerov@mba:~/events/terraform (master) $ export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES

ਟੈਰਾਫਾਰਮ ਵਾਲੇ ਫੋਲਡਰ ਵਿੱਚ ਅਸੀਂ ਲੋੜੀਂਦੇ ਸਰੋਤ ਬਣਾਉਂਦੇ ਹਾਂ:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_compute_instance.build -target yandex_compute_instance.monitoring -target yandex_compute_instance.kafka
yandex_vpc_network.internal: Refreshing state... [id=enp2g2rhile7gbqlbrkr]
data.yandex_compute_image.ubuntu_image: Refreshing state...
yandex_vpc_subnet.internal-a: Refreshing state... [id=e9b1dad6mgoj2v4funog]

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

... skipped ...

Plan: 3 to add, 0 to change, 0 to destroy.

... skipped ...

ਜੇ ਸਭ ਕੁਝ ਸਫਲਤਾਪੂਰਵਕ ਖਤਮ ਹੋ ਗਿਆ (ਅਤੇ ਇਹ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ), ਤਾਂ ਸਾਡੇ ਕੋਲ ਤਿੰਨ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਹੋਣਗੀਆਂ:

1. ਬਿਲਡ - ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਟੈਸਟ ਕਰਨ ਅਤੇ ਬਣਾਉਣ ਲਈ ਇੱਕ ਮਸ਼ੀਨ। ਡੌਕਰ ਜਵਾਬੀ ਦੁਆਰਾ ਆਪਣੇ ਆਪ ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਸੀ।
2. ਨਿਗਰਾਨੀ - ਇੱਕ ਨਿਗਰਾਨੀ ਮਸ਼ੀਨ - prometheus & grafana ਇਸ 'ਤੇ ਇੰਸਟਾਲ ਹੈ. ਲੌਗਇਨ / ਪਾਸਵਰਡ ਸਟੈਂਡਰਡ: ਐਡਮਿਨ / ਐਡਮਿਨ
3. ਕਾਫਕਾ ਇੱਕ ਛੋਟੀ ਮਸ਼ੀਨ ਹੈ ਜਿਸ ਵਿੱਚ ਕਾਫਕਾ ਸਥਾਪਿਤ ਹੈ, ਪੋਰਟ 9092 'ਤੇ ਪਹੁੰਚਯੋਗ ਹੈ।

ਆਉ ਇਹ ਯਕੀਨੀ ਕਰੀਏ ਕਿ ਉਹ ਸਾਰੇ ਸਥਾਨ 'ਤੇ ਹਨ:

vozerov@mba:~/events (master) $ yc compute instance list
+----------------------+------------+---------------+---------+---------------+-------------+
|          ID          |    NAME    |    ZONE ID    | STATUS  |  EXTERNAL IP  | INTERNAL IP |
+----------------------+------------+---------------+---------+---------------+-------------+
| fhm081u8bkbqf1pa5kgj | monitoring | ru-central1-a | RUNNING | 84.201.159.71 | 172.16.1.35 |
| fhmf37k03oobgu9jmd7p | kafka      | ru-central1-a | RUNNING | 84.201.173.41 | 172.16.1.31 |
| fhmt9pl1i8sf7ga6flgp | build      | ru-central1-a | RUNNING | 84.201.132.3  | 172.16.1.26 |
+----------------------+------------+---------------+---------+---------------+-------------+

ਸਰੋਤ ਥਾਂ 'ਤੇ ਹਨ, ਅਤੇ ਇੱਥੋਂ ਅਸੀਂ ਉਨ੍ਹਾਂ ਦੇ IP ਪਤੇ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਸ ਤੋਂ ਬਾਅਦ ਮੈਂ ssh ਦੁਆਰਾ ਜੁੜਨ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ IP ਪਤਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗਾ। ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਟੈਰਾਫਾਰਮ ਨਾਲ ਜੁੜਿਆ ਕਲਾਉਡਫਲੇਅਰ ਖਾਤਾ ਹੈ, ਤਾਂ ਤਾਜ਼ੇ ਬਣਾਏ ਗਏ DNS ਨਾਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਬੇਝਿਜਕ ਮਹਿਸੂਸ ਕਰੋ।
ਤਰੀਕੇ ਨਾਲ, ਜਦੋਂ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਬਣਾਉਂਦੇ ਹੋ, ਇੱਕ ਅੰਦਰੂਨੀ IP ਅਤੇ ਇੱਕ ਅੰਦਰੂਨੀ DNS ਨਾਮ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਨਾਮ ਦੁਆਰਾ ਨੈਟਵਰਕ ਦੇ ਅੰਦਰ ਸਰਵਰਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕੋ:

ubuntu@build:~$ ping kafka.ru-central1.internal
PING kafka.ru-central1.internal (172.16.1.31) 56(84) bytes of data.
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=1 ttl=63 time=1.23 ms
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=2 ttl=63 time=0.625 ms
^C
--- kafka.ru-central1.internal ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.625/0.931/1.238/0.308 ms

ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ kafk ਨਾਲ ਅੰਤਮ ਬਿੰਦੂ ਦਰਸਾਉਣ ਲਈ ਇਹ ਸਾਡੇ ਲਈ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ।

ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ

ਬਹੁਤ ਵਧੀਆ, ਇੱਥੇ ਸਰਵਰ ਹਨ, ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਹੈ - ਜੋ ਕੁਝ ਬਚਦਾ ਹੈ ਉਸਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਅਤੇ ਪ੍ਰਕਾਸ਼ਤ ਕਰਨਾ ਹੈ. ਬਿਲਡ ਲਈ ਅਸੀਂ ਆਮ ਡੌਕਰ ਬਿਲਡ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਪਰ ਇੱਕ ਚਿੱਤਰ ਸਟੋਰੇਜ ਵਜੋਂ ਅਸੀਂ ਯਾਂਡੇਕਸ - ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ਤੋਂ ਇੱਕ ਸੇਵਾ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ. ਪਰ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਪਹਿਲੀਆਂ ਚੀਜ਼ਾਂ.

ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਬਿਲਡ ਮਸ਼ੀਨ ਵਿੱਚ ਕਾਪੀ ਕਰਦੇ ਹਾਂ, ssh ਦੁਆਰਾ ਲੌਗਇਨ ਕਰਦੇ ਹਾਂ ਅਤੇ ਚਿੱਤਰ ਨੂੰ ਇਕੱਠਾ ਕਰਦੇ ਹਾਂ:

vozerov@mba:~/events/terraform (master) $ cd ..
vozerov@mba:~/events (master) $ rsync -av app/ [email protected]:app/

... skipped ...

sent 3849 bytes  received 70 bytes  7838.00 bytes/sec
total size is 3644  speedup is 0.93

vozerov@mba:~/events (master) $ ssh 84.201.132.3 -l ubuntu
ubuntu@build:~$ cd app
ubuntu@build:~/app$ sudo docker build -t app .
Sending build context to Docker daemon  6.144kB
Step 1/9 : FROM golang:latest AS build
... skipped ...

Successfully built 9760afd8ef65
Successfully tagged app:latest

ਅੱਧੀ ਲੜਾਈ ਹੋ ਗਈ ਹੈ - ਹੁਣ ਅਸੀਂ ਇਸ ਨੂੰ ਲਾਂਚ ਕਰਕੇ ਅਤੇ ਕਾਫਕਾ ਨੂੰ ਭੇਜ ਕੇ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹਾਂ:

ubuntu@build:~/app$ sudo docker run --name app -d -p 8080:8080 app /app/app -kafka=kafka.ru-central1.internal:9092</code>

С локальной машинки можно отправить тестовый event и посмотреть на ответ:

<code>vozerov@mba:~/events (master) $ curl -D - -s -X POST -d '{"key1":"data1"}' http://84.201.132.3:8080/post
HTTP/1.1 200 OK
Content-Type: application/json
Date: Mon, 13 Apr 2020 13:53:54 GMT
Content-Length: 41

{"status":"ok","partition":0,"Offset":0}
vozerov@mba:~/events (master) $

ਐਪਲੀਕੇਸ਼ਨ ਨੇ ਰਿਕਾਰਡਿੰਗ ਦੀ ਸਫਲਤਾ ਦੇ ਨਾਲ ਜਵਾਬ ਦਿੱਤਾ ਅਤੇ ਭਾਗ ਅਤੇ ਆਫਸੈੱਟ ਦੀ ਆਈਡੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸੁਨੇਹਾ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਸੀ। ਸਿਰਫ਼ Yandex.Cloud ਵਿੱਚ ਇੱਕ ਰਜਿਸਟਰੀ ਬਣਾਉਣਾ ਬਾਕੀ ਹੈ ਅਤੇ ਉੱਥੇ ਸਾਡਾ ਚਿੱਤਰ ਅੱਪਲੋਡ ਕਰਨਾ ਹੈ (ਤਿੰਨ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ registry.tf ਫਾਈਲ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ)। ਸਟੋਰੇਜ ਬਣਾਓ:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_container_registry.events

... skipped ...

Plan: 1 to add, 0 to change, 0 to destroy.

... skipped ...

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ਵਿੱਚ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ - ਇੱਕ oauth ਟੋਕਨ, ਇੱਕ iam ਟੋਕਨ, ਜਾਂ ਇੱਕ ਸੇਵਾ ਖਾਤਾ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਲੱਭੇ ਜਾ ਸਕਦੇ ਹਨ। https://cloud.yandex.ru/docs/container-registry/operations/authentication. ਅਸੀਂ ਸੇਵਾ ਖਾਤਾ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਅਸੀਂ ਇੱਕ ਖਾਤਾ ਬਣਾਵਾਂਗੇ:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_iam_service_account.docker -target yandex_resourcemanager_folder_iam_binding.puller -target yandex_resourcemanager_folder_iam_binding.pusher

... skipped ...

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.

ਹੁਣ ਸਭ ਕੁਝ ਇਸ ਲਈ ਇੱਕ ਕੁੰਜੀ ਬਣਾਉਣਾ ਬਾਕੀ ਹੈ:

vozerov@mba:~/events/terraform (master) $ yc iam key create --service-account-name docker -o key.json
id: ajej8a06kdfbehbrh91p
service_account_id: ajep6d38k895srp9osij
created_at: "2020-04-13T14:00:30Z"
key_algorithm: RSA_2048

ਅਸੀਂ ਆਪਣੇ ਸਟੋਰੇਜ ਦੀ ਆਈਡੀ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ, ਕੁੰਜੀ ਟ੍ਰਾਂਸਫਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਲੌਗ ਇਨ ਕਰਦੇ ਹਾਂ:

vozerov@mba:~/events/terraform (master) $ scp key.json [email protected]:
key.json                                                                                                                    100% 2392   215.1KB/s   00:00

vozerov@mba:~/events/terraform (master) $ ssh 84.201.132.3 -l ubuntu

ubuntu@build:~$ cat key.json | sudo docker login --username json_key --password-stdin cr.yandex
WARNING! Your password will be stored unencrypted in /home/ubuntu/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
ubuntu@build:~$

ਚਿੱਤਰ ਨੂੰ ਰਜਿਸਟਰੀ ਵਿੱਚ ਅੱਪਲੋਡ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ID ਦੀ ਲੋੜ ਹੈ, ਅਸੀਂ ਇਸਨੂੰ yc ਉਪਯੋਗਤਾ ਤੋਂ ਲੈਂਦੇ ਹਾਂ:

vozerov@mba:~ $ yc container registry get events
id: crpdgj6c9umdhgaqjfmm
folder_id:
name: events
status: ACTIVE
created_at: "2020-04-13T13:56:41.914Z"

ਉਸ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਆਪਣੀ ਤਸਵੀਰ ਨੂੰ ਇੱਕ ਨਵੇਂ ਨਾਮ ਨਾਲ ਟੈਗ ਕਰਦੇ ਹਾਂ ਅਤੇ ਅੱਪਲੋਡ ਕਰਦੇ ਹਾਂ:

ubuntu@build:~$ sudo docker tag app cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
ubuntu@build:~$ sudo docker push cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
The push refers to repository [cr.yandex/crpdgj6c9umdhgaqjfmm/events]
8c286e154c6e: Pushed
477c318b05cb: Pushed
beee9f30bc1f: Pushed
v1: digest: sha256:1dd5aaa9dbdde2f60d833be0bed1c352724be3ea3158bcac3cdee41d47c5e380 size: 946

ਅਸੀਂ ਪੁਸ਼ਟੀ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਚਿੱਤਰ ਸਫਲਤਾਪੂਰਵਕ ਲੋਡ ਹੋਇਆ ਹੈ:

vozerov@mba:~/events/terraform (master) $ yc container repository list
+----------------------+-----------------------------+
|          ID          |            NAME             |
+----------------------+-----------------------------+
| crpe8mqtrgmuq07accvn | crpdgj6c9umdhgaqjfmm/events |
+----------------------+-----------------------------+

ਤਰੀਕੇ ਨਾਲ, ਜੇਕਰ ਤੁਸੀਂ ਲੀਨਕਸ ਮਸ਼ੀਨ 'ਤੇ yc ਸਹੂਲਤ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ

yc container registry configure-docker

ਡੌਕਰ ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ ਲਈ.

ਸਿੱਟਾ

ਅਸੀਂ ਬਹੁਤ ਸਖਤ ਮਿਹਨਤ ਕੀਤੀ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ:

1. ਅਸੀਂ ਆਪਣੀ ਭਵਿੱਖ ਦੀ ਸੇਵਾ ਦੇ ਆਰਕੀਟੈਕਚਰ ਦੇ ਨਾਲ ਆਏ ਹਾਂ।
2. ਅਸੀਂ ਗੋਲੰਗ ਵਿੱਚ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਲਿਖੀ ਹੈ ਜੋ ਸਾਡੇ ਵਪਾਰਕ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰਦੀ ਹੈ।
3. ਅਸੀਂ ਇਸਨੂੰ ਇਕੱਠਾ ਕੀਤਾ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ਵਿੱਚ ਡੋਲ੍ਹ ਦਿੱਤਾ।

ਅਗਲੇ ਹਿੱਸੇ ਵਿੱਚ, ਅਸੀਂ ਦਿਲਚਸਪ ਸਮੱਗਰੀ ਵੱਲ ਅੱਗੇ ਵਧਾਂਗੇ - ਅਸੀਂ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਜਾਰੀ ਕਰਾਂਗੇ ਅਤੇ ਅੰਤ ਵਿੱਚ ਇਸ 'ਤੇ ਲੋਡ ਲਾਂਚ ਕਰਾਂਗੇ। ਸਵਿਚ ਨਾ ਕਰੋ!

ਇਹ ਸਮੱਗਰੀ ਓਪਨ ਵਰਕਸ਼ਾਪ REBRAIN & Yandex.Cloud ਦੀ ਵੀਡੀਓ ਰਿਕਾਰਡਿੰਗ ਵਿੱਚ ਹੈ: ਅਸੀਂ Yandex Cloud 'ਤੇ ਪ੍ਰਤੀ ਸਕਿੰਟ 10 ਬੇਨਤੀਆਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੇ ਹਾਂ - https://youtu.be/cZLezUm0ekE

ਜੇਕਰ ਤੁਸੀਂ ਅਜਿਹੇ ਸਮਾਗਮਾਂ ਵਿੱਚ ਔਨਲਾਈਨ ਸ਼ਾਮਲ ਹੋਣ ਅਤੇ ਅਸਲ ਸਮੇਂ ਵਿੱਚ ਸਵਾਲ ਪੁੱਛਣ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਇਸ ਨਾਲ ਜੁੜੋ REBRAIN ਚੈਨਲ ਦੁਆਰਾ DevOps.

ਅਸੀਂ ਅਜਿਹੇ ਸਮਾਗਮ ਦੀ ਮੇਜ਼ਬਾਨੀ ਕਰਨ ਦੇ ਮੌਕੇ ਲਈ Yandex.Cloud ਦਾ ਵਿਸ਼ੇਸ਼ ਧੰਨਵਾਦ ਕਹਿਣਾ ਚਾਹਾਂਗੇ। ਉਹਨਾਂ ਨਾਲ ਲਿੰਕ - https://cloud.yandex.ru/prices

ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਲਾਉਡ 'ਤੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ ਜਾਂ ਤੁਹਾਡੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਬਾਰੇ ਸਵਾਲ ਹਨ, ਇੱਕ ਬੇਨਤੀ ਦਰਜ ਕਰਨ ਲਈ ਮੁਫ਼ਤ ਮਹਿਸੂਸ ਕਰੋ.

PS ਸਾਡੇ ਕੋਲ ਪ੍ਰਤੀ ਮਹੀਨਾ 2 ਮੁਫਤ ਆਡਿਟ ਹਨ, ਸ਼ਾਇਦ ਤੁਹਾਡਾ ਪ੍ਰੋਜੈਕਟ ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੋਵੇਗਾ।

ਸਰੋਤ: www.habr.com