અમે Yandex.Cloud માં 10 ઇવેન્ટ્સ સ્વીકારીએ છીએ. ભાગ 000

દરેકને હેલો, મિત્રો!

* આ લેખ REBRAIN અને Yandex.Cloud ઓપન વર્કશોપ પર આધારિત છે, જો તમે વિડિઓ જોવાનું પસંદ કરો છો, તો તમે તેને આ લિંક પર શોધી શકો છો - https://youtu.be/cZLezUm0ekE

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

મને સંપૂર્ણ ખાતરી છે કે મોટાભાગના ઓનલાઈન (અને માત્ર નહીં) વ્યવસાયો કોઈક રીતે તેમના વપરાશકર્તાઓ અને તેમની ક્રિયાઓ વિશે માહિતીનો પહાડ એકત્રિત કરે છે. ઓછામાં ઓછા, ચોક્કસ નિર્ણયો લેવા માટે આ જરૂરી છે - ઉદાહરણ તરીકે, જો તમે ઑનલાઇન રમતનું સંચાલન કરો છો, તો તમે આંકડા જોઈ શકો છો કે વપરાશકર્તાઓ કયા સ્તરે મોટાભાગે અટવાઈ જાય છે અને તમારું રમકડું કાઢી નાખે છે. અથવા શા માટે વપરાશકર્તાઓ કંઈપણ ખરીદ્યા વિના તમારી સાઇટ છોડી દે છે (હેલો, Yandex.Metrica).

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

હું તરત જ એક આરક્ષણ કરવા માંગુ છું કે અમે એક બેઠકમાં બધું ગોઠવી શકીશું નહીં - આ માટે અમને શ્રેણીમાં ઘણા લેખોની જરૂર પડશે. રચના વિશે થોડું:

ભાગ 1 (તમે વાંચી રહ્યા છો). અમે સોલ્યુશનની વિશિષ્ટતાઓ અને આર્કિટેક્ચર પર નિર્ણય કરીશું, અને ગોલાંગમાં એપ્લિકેશન પણ લખીશું.
ભાગ 2. અમે અમારી એપ્લિકેશનને પ્રોડક્શનમાં રિલીઝ કરીએ છીએ, તેને સ્કેલેબલ બનાવીએ છીએ અને લોડનું પરીક્ષણ કરીએ છીએ.
ભાગ 3. ચાલો એ સમજવાનો પ્રયત્ન કરીએ કે શા માટે આપણે સંદેશાઓને ફાઇલોમાં નહીં પણ બફરમાં સંગ્રહિત કરવાની જરૂર છે, અને કાફકા, રેબિટએમક્યુ અને યાન્ડેક્સ કતાર સેવાની તુલના પણ કરીએ.
ભાગ 4 અમે ક્લિકહાઉસ ક્લસ્ટર ગોઠવીશું, ત્યાં બફરમાંથી ડેટા ટ્રાન્સફર કરવા માટે સ્ટ્રીમિંગ સેવા લખીશું અને ડેટાલેન્સમાં વિઝ્યુલાઇઝેશન સેટ કરીશું.
ભાગ 5 ચાલો સમગ્ર ઈન્ફ્રાસ્ટ્રક્ચરને યોગ્ય આકારમાં લાવીએ - gitlab ci નો ઉપયોગ કરીને ci/cd સેટ કરો, પ્રોમિથિયસ અને કોન્સ્યુલનો ઉપયોગ કરીને મોનિટરિંગ અને સેવા શોધને કનેક્ટ કરો.

ટી.કે

પ્રથમ, ચાલો સંદર્ભની શરતો બનાવીએ - પરિણામ તરીકે આપણે બરાબર શું મેળવવા માંગીએ છીએ.

1. અમે event.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. આકૃતિ કાફકાને બફર તરીકે બતાવે છે, જોકે, અલબત્ત, આ સ્તરે અન્ય સમાન સેવાઓનો ઉપયોગ કરી શકાય છે. અમે ત્રીજા લેખમાં કાફકા, રેબિટએમક્યુ અને વાયક્યુની તુલના કરીશું.

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. ત્રણ અંતિમ બિંદુઓ કે જે અમારી એપ્લિકેશન પ્રક્રિયા કરે છે:

• /સ્ટેટસ - અમે જીવંત છીએ તે બતાવવા માટે ફક્ત ઠીક પાછા ફરો. જો કે તમે કેટલાક ચેક ઉમેરી શકો છો, જેમ કે કાફકા ક્લસ્ટરની ઉપલબ્ધતા.
• /મેટ્રિક્સ - આ url અનુસાર, પ્રોમિથિયસ ક્લાયંટ તેણે એકત્રિત કરેલ મેટ્રિક્સ પરત કરશે.
• /post એ મુખ્ય અંતિમ બિંદુ છે જ્યાં અંદર json સાથે POST વિનંતીઓ મોકલવામાં આવશે. અમારી એપ્લિકેશન માન્યતા માટે json ને તપાસે છે અને જો બધું બરાબર છે, તો તે કાફકા ક્લસ્ટરમાં ડેટા લખે છે.

હું એક આરક્ષણ કરીશ કે કોડ સંપૂર્ણ નથી - તે પૂર્ણ થઈ શકે છે (અને જોઈએ!) ઉદાહરણ તરીકે, તમે બિલ્ટ-ઇન નેટ/http નો ઉપયોગ કરવાનું બંધ કરી શકો છો અને વધુ ઝડપી HTTP પર સ્વિચ કરી શકો છો. અથવા તમે જેસન વેલિડિટી ચેકને પછીના તબક્કામાં ખસેડીને પ્રોસેસિંગ સમય અને સીપીયુ સંસાધનો મેળવી શકો છો - જ્યારે ડેટા બફરમાંથી ક્લિકહાઉસ ક્લસ્ટરમાં ટ્રાન્સફર થાય છે.

સમસ્યાના વિકાસની બાજુ ઉપરાંત, અમે તરત જ અમારા ભાવિ ઇન્ફ્રાસ્ટ્રક્ચર વિશે વિચાર્યું અને અમારી એપ્લિકેશનને ડોકર દ્વારા જમાવવાનું નક્કી કર્યું. એપ્લિકેશન બનાવવા માટેની અંતિમ ડોકરફાઇલ છે 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

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

જો તમે Windows માટે ક્લાયંટ ઇન્સ્ટોલ કરવા માંગો છો, તો તમે સૂચનાઓનો ઉપયોગ કરી શકો છો અહીં અને પછી ચલાવો 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 config પ્રોફાઇલ બનાવો અને તેમની વચ્ચે સ્વિચ કરીને અલગ સેટિંગ્સ સાથે વધારાની પ્રોફાઇલ બનાવી શકો છો.

ઉપરોક્ત પદ્ધતિઓ ઉપરાંત, 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 રૂપરેખા સૂચિમાંથી લઈ શકાય છે, કારણ કે અમે કન્સોલ યુટિલિટી પહેલાથી જ ગોઠવેલ છે. હું તમને .gitignore માં તરત જ private.auto.tfvars ઉમેરવાની સલાહ આપું છું, જેથી આકસ્મિક રીતે ખાનગી ડેટા પ્રકાશિત ન થાય.

ખાનગી.auto.tfvars માં અમે DNS રેકોર્ડ બનાવવા અને મુખ્ય ડોમેન events.kis.im ને અમારા સર્વર્સ પર પ્રોક્સી કરવા - ક્લાઉડફ્લેરમાંથી ડેટાનો પણ ઉલ્લેખ કર્યો છે. જો તમે ક્લાઉડફ્લેરનો ઉપયોગ કરવા નથી માંગતા, તો પછી main.tf અને dns.tf ફાઇલમાં ક્લાઉડફ્લેર પ્રદાતાના પ્રારંભને દૂર કરો, જે જરૂરી dns રેકોર્ડ્સ બનાવવા માટે જવાબદાર છે.

અમારા કાર્યમાં અમે ત્રણેય પદ્ધતિઓને જોડીશું - વેબ ઇન્ટરફેસ, કન્સોલ યુટિલિટી અને ટેરાફોર્મ.

વર્ચ્યુઅલ નેટવર્ક્સ

સાચું કહું તો, તમે આ પગલું છોડી શકો છો, કારણ કે જ્યારે તમે નવું ક્લાઉડ બનાવશો, ત્યારે તમારી પાસે આપોઆપ એક અલગ નેટવર્ક અને 3 સબનેટ બનાવવામાં આવશે - દરેક ઉપલબ્ધતા ઝોન માટે એક. પરંતુ અમે હજુ પણ અમારા પ્રોજેક્ટ માટે તેના પોતાના એડ્રેસિંગ સાથે અલગ નેટવર્ક બનાવવા માંગીએ છીએ. Yandex.Cloud માં નેટવર્ક કેવી રીતે કાર્ય કરે છે તેની સામાન્ય રેખાકૃતિ નીચેની આકૃતિમાં બતાવવામાં આવી છે (પ્રમાણિકપણે અહીંથી લેવામાં આવી છે. https://cloud.yandex.ru/docs/vpc/concepts/)

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

નેટવર્ક બનાવટનું વર્ણન રીપોઝીટરીમાંથી network.tf ફાઇલમાં કરવામાં આવ્યું છે. ત્યાં આપણે એક સામાન્ય ખાનગી નેટવર્ક આંતરિક બનાવીએ છીએ અને તેની સાથે ત્રણ સબનેટને વિવિધ ઉપલબ્ધતા ઝોનમાં જોડીએ છીએ - આંતરિક-a (172.16.1.0/24), આંતરિક-b (172.16.2.0/24), આંતરિક-c (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. આને ફરીથી થતું અટકાવવા માટે, ટેરાફોર્મ લોન્ચ કરતા પહેલા 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. મોનીટરીંગ - એક મોનીટરીંગ મશીન - પ્રોમીથિયસ અને ગ્રાફના તેના પર સ્થાપિત થયેલ છે. લોગિન / પાસવર્ડ સ્ટાન્ડર્ડ: એડમિન / એડમિન
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 દ્વારા કનેક્ટ કરવા અને એપ્લિકેશનને ચકાસવા માટે આઇપી એડ્રેસનો ઉપયોગ કરીશ. જો તમારી પાસે ટેરાફોર્મ સાથે કનેક્ટેડ ક્લાઉડફ્લેર એકાઉન્ટ હોય, તો તાજા બનાવેલા 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.

કન્ટેનર રજિસ્ટ્રીમાં પ્રમાણીકરણ કરવાની ઘણી રીતો છે - ઑથ ટોકન, 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 |
+----------------------+-----------------------------+

માર્ગ દ્વારા, જો તમે Linux મશીન પર 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