ટેરાફોર્મર - ઈન્ફ્રાસ્ટ્રક્ચર ટુ કોડ

હું તમને નવા CLI ટૂલ વિશે જણાવવા માંગુ છું જે મેં જૂની સમસ્યાને ઉકેલવા માટે લખ્યું હતું.

સમસ્યા

ટેરાફોર્મ લાંબા સમયથી Devops/Cloud/IT સમુદાયમાં પ્રમાણભૂત છે. કોડ તરીકે ઇન્ફ્રાસ્ટ્રક્ચર સાથે કામ કરવા માટે વસ્તુ ખૂબ જ અનુકૂળ અને ઉપયોગી છે. ટેરાફોર્મમાં ઘણા આનંદ તેમજ ઘણા કાંટા, તીક્ષ્ણ છરીઓ અને રેક્સ છે.
ટેરાફોર્મ સાથે નવી વસ્તુઓ બનાવવી અને પછી તેને મેનેજ કરવી, બદલવી અથવા કાઢી નાખવી એ ખૂબ જ અનુકૂળ છે. જેમની પાસે ક્લાઉડમાં વિશાળ ઈન્ફ્રાસ્ટ્રક્ચર છે અને ટેરાફોર્મ દ્વારા બનાવવામાં આવ્યું નથી તેઓએ શું કરવું જોઈએ? સંપૂર્ણ ક્લાઉડને ફરીથી લખવું અને ફરીથી બનાવવું એ કોઈક રીતે ખર્ચાળ અને અસુરક્ષિત છે.
મને આ સમસ્યા 2 જોબ પર આવી, સૌથી સરળ ઉદાહરણ એ છે કે જ્યારે તમે ટેરાફોર્મ ફાઇલોના રૂપમાં ગિટમાં બધું જ હોય ​​તેવું ઇચ્છો છો, પરંતુ તમારી પાસે 250+ બકેટ્સ છે અને તેને હાથથી ટેરાફોર્મમાં લખવાનું ઘણું છે.
છે મુદ્દો ટેરાફોમમાં 2014 થી જે આયાત થશે તેવી આશા સાથે 2016 માં બંધ કરવામાં આવી હતી.

સામાન્ય રીતે, બધું ફક્ત જમણેથી ડાબે ચિત્રમાં જેવું છે

ચેતવણીઓ: લેખક તેના અડધા જીવન માટે રશિયામાં રહેતા નથી અને રશિયનમાં થોડું લખે છે. જોડણીની ભૂલોથી સાવધ રહો.

ઉકેલો

1. AWS માટે તૈયાર અને જૂના ઉકેલો છે ટેરાફોર્મિંગ. જ્યારે મેં તેના દ્વારા મારી 250+ ડોલ મેળવવાનો પ્રયાસ કર્યો, ત્યારે મને સમજાયું કે ત્યાં બધું જ ખરાબ હતું. AWS લાંબા સમયથી ઘણા નવા વિકલ્પો રજૂ કરી રહ્યું છે, પરંતુ ટેરાફોર્મિંગ તેમના વિશે જાણતું નથી અને સામાન્ય રીતે તે રૂબી છે ટેમ્પલેટ છૂટાછવાયા દેખાય છે. સાંજે 2 વાગ્યા પછી મેં મોકલ્યું વિનંતી ખેંચો ત્યાં વધુ સુવિધાઓ ઉમેરવા અને સમજાયું કે આવા ઉકેલ બિલકુલ યોગ્ય નથી.
ટેરાફોર્મિંગ કેવી રીતે કામ કરે છે: તે AWS SDK માંથી ડેટા લે છે અને ટેમ્પલેટ દ્વારા tf અને tfstate જનરેટ કરે છે.
અહીં 3 સમસ્યાઓ છે:
1. અપડેટ્સમાં હંમેશા અંતર રહેશે
2. tf ફાઇલો ક્યારેક તૂટેલી બહાર આવે છે
3. tfstate tf થી અલગ ભેગી કરવામાં આવે છે અને હંમેશા એકીકૃત થતું નથી
સામાન્ય રીતે, પરિણામ મેળવવું મુશ્કેલ છે જેમાં `ટેરાફોર્મ પ્લાન` કહે છે કે તેમાં કોઈ ફેરફાર નથી

2. `ટેરાફોર્મ આયાત` એ ટેરાફોર્મમાં બિલ્ટ-ઇન કમાન્ડ છે. તે કેવી રીતે કામ કરે છે?
તમે નામ અને સંસાધનના પ્રકાર સાથે ખાલી TF ફાઇલ લખો, પછી `ટેરાફોર્મ આયાત` ચલાવો અને સંસાધન ID પાસ કરો. ટેરાફોર્મ પ્રદાતાનો સંપર્ક કરે છે, ડેટા મેળવે છે અને tfstate ફાઇલ બનાવે છે.
અહીં 3 સમસ્યાઓ છે:
1. અમને ફક્ત tfstate ફાઇલ મળે છે, અને tf ખાલી છે, તમારે તેને મેન્યુઅલી લખવાની અથવા તેને tfstate થી કન્વર્ટ કરવાની જરૂર છે.
2. એક સમયે માત્ર એક સંસાધન સાથે કામ કરી શકે છે અને તમામ સંસાધનોને સમર્થન આપતું નથી. અને મારે 250+ ડોલ સાથે ફરીથી શું કરવું જોઈએ?
3. તમારે સંસાધનોની ID જાણવાની જરૂર છે - એટલે કે, તમારે તેને કોડમાં લપેટી લેવાની જરૂર છે જે સંસાધનોની સૂચિ મેળવે છે
સામાન્ય રીતે, પરિણામ આંશિક છે અને સારી રીતે માપવામાં આવતું નથી

મારો નિર્ણય

જરૂરીયાતો:
1. સંસાધનો માટે tf અને tfstate ફાઇલો બનાવવાની ક્ષમતા. ઉદાહરણ તરીકે, તમામ બકેટ્સ/સિક્યોરિટી ગ્રૂપ/લોડ બેલેન્સર ડાઉનલોડ કરો અને તે `ટેરાફોર્મ પ્લાન` પરત આવ્યો કે તેમાં કોઈ ફેરફાર નથી.
2. તમારે 2 GCP + AWS વાદળોની જરૂર છે
3. વૈશ્વિક સોલ્યુશન જે દર વખતે અપડેટ કરવામાં સરળ છે અને 3 દિવસના કામ માટે દરેક સંસાધન પર સમય બગાડતો નથી
4. તેને ઓપન સોર્સ બનાવો - દરેકને સમાન સમસ્યા છે

ગો લેંગ્વેજ એટલે જ મને તે ગમે છે, અને તેમાં HCL ફાઇલો બનાવવા માટેની લાઇબ્રેરી છે જેનો ઉપયોગ ટેરાફોર્મમાં થાય છે + ટેરાફોર્મમાં ઘણો કોડ જે ઉપયોગી થઈ શકે છે.

પાથ

પ્રથમ પ્રયાસ
મેં એક સરળ સંસ્કરણથી શરૂઆત કરી. જરૂરી સંસાધન માટે SDK દ્વારા ક્લાઉડનો સંપર્ક કરવો અને તેને ટેરાફોર્મ માટે ફીલ્ડમાં રૂપાંતરિત કરવું. સુરક્ષા જૂથ પર પ્રયાસ તરત જ મૃત્યુ પામ્યો કારણ કે મને ફક્ત સુરક્ષા જૂથને કન્વર્ટ કરવા માટે 1.5 દિવસ પસંદ ન હતા (અને ત્યાં ઘણા બધા સંસાધનો છે). લાંબા સમય સુધી અને પછી ક્ષેત્રો બદલી/ઉમેરી શકાય છે

બીજો પ્રયાસ
વર્ણવેલ વિચારના આધારે અહીં. માત્ર લો અને tfstate ને tf માં કન્વર્ટ કરો. બધા ડેટા ત્યાં છે અને ક્ષેત્રો સમાન છે. ઘણા સંસાધનો માટે સંપૂર્ણ tfstate કેવી રીતે મેળવવું?? આ તે છે જ્યાં `ટેરાફોર્મ રિફ્રેશ` આદેશ બચાવમાં આવ્યો. ટેરાફોર્મ તમામ સંસાધનો tfstate માં લે છે અને ID દ્વારા, તેમના પરનો ડેટા ખેંચે છે અને tfstate પર બધું લખે છે. એટલે કે, ફક્ત નામ અને ID સાથે ખાલી tfstate બનાવો, `terraform refresh` ચલાવો અને પછી અમને સંપૂર્ણ tfstate મળે છે. હુરે!
હવે ચાલો tfstate to tf માટે કન્વર્ટર લખવાની પુનરાવર્તિત પોર્નોગ્રાફી કરીએ. જેમણે ક્યારેય tfstate વાંચ્યું નથી તેમના માટે તે JSON છે, પરંતુ ખાસ.
અહીં તેના મહત્વપૂર્ણ ભાગ લક્ષણો છે

 "attributes": {
                            "id": "default/backend-logging-load-deployment",
                            "metadata.#": "1",
                            "metadata.0.annotations.%": "0",
                            "metadata.0.generate_name": "",
                            "metadata.0.generation": "24",
                            "metadata.0.labels.%": "1",
                            "metadata.0.labels.app": "backend-logging",
                            "metadata.0.name": "backend-logging-load-deployment",
                            "metadata.0.namespace": "default",
                            "metadata.0.resource_version": "109317427",
                            "metadata.0.self_link": "/apis/apps/v1/namespaces/default/deployments/backend-logging-load-deployment",
                            "metadata.0.uid": "300ecda1-4138-11e9-9d5d-42010a8400b5",
                            "spec.#": "1",
                            "spec.0.min_ready_seconds": "0",
                            "spec.0.paused": "false",
                            "spec.0.progress_deadline_seconds": "600",
                            "spec.0.replicas": "1",
                            "spec.0.revision_history_limit": "10",
                            "spec.0.selector.#": "1",

ત્યાં છે:
1. આઈડી - શબ્દમાળા
2. મેટાડેટા - કદ 1 ની એરે અને તેમાં ફીલ્ડ્સ સાથેનું ઑબ્જેક્ટ જે નીચે વર્ણવેલ છે
3. સ્પેક - કદ 1 નું હેશ અને કી, તેમાં મૂલ્ય
ટૂંકમાં, એક મનોરંજક ફોર્મેટ, બધું ઘણા સ્તરો ઊંડા હોઈ શકે છે

                   "spec.#": "1",
                            "spec.0.min_ready_seconds": "0",
                            "spec.0.paused": "false",
                            "spec.0.progress_deadline_seconds": "600",
                            "spec.0.replicas": "1",
                            "spec.0.revision_history_limit": "10",
                            "spec.0.selector.#": "1",
                            "spec.0.selector.0.match_expressions.#": "0",
                            "spec.0.selector.0.match_labels.%": "1",
                            "spec.0.selector.0.match_labels.app": "backend-logging-load",
                            "spec.0.strategy.#": "0",
                            "spec.0.template.#": "1",
                            "spec.0.template.0.metadata.#": "1",
                            "spec.0.template.0.metadata.0.annotations.%": "0",
                            "spec.0.template.0.metadata.0.generate_name": "",
                            "spec.0.template.0.metadata.0.generation": "0",
                            "spec.0.template.0.metadata.0.labels.%": "1",
                            "spec.0.template.0.metadata.0.labels.app": "backend-logging-load",
                            "spec.0.template.0.metadata.0.name": "",
                            "spec.0.template.0.metadata.0.namespace": "",
                            "spec.0.template.0.metadata.0.resource_version": "",
                            "spec.0.template.0.metadata.0.self_link": "",
                            "spec.0.template.0.metadata.0.uid": "",
                            "spec.0.template.0.spec.#": "1",
                            "spec.0.template.0.spec.0.active_deadline_seconds": "0",
                            "spec.0.template.0.spec.0.container.#": "1",
                            "spec.0.template.0.spec.0.container.0.args.#": "3",

સામાન્ય રીતે, જો કોઈને ઇન્ટરવ્યૂ માટે પ્રોગ્રામિંગ સમસ્યા જોઈતી હોય, તો તેમને આ કાર્ય માટે પાર્સર લખવા માટે કહો :)
ભૂલો વિના પાર્સર લખવાના ઘણા પ્રયત્નો પછી, મને તેનો ભાગ ટેરાફોર્મ કોડમાં મળ્યો, અને સૌથી મહત્વપૂર્ણ ભાગ. અને બધું બરાબર કામ કરતું લાગતું હતું

ત્રણ પ્રયાસ
ટેરાફોર્મ પ્રદાતાઓ દ્વિસંગી છે જેમાં ક્લાઉડ API સાથે કામ કરવા માટેના તમામ સંસાધનો અને તર્ક સાથેનો કોડ હોય છે. દરેક ક્લાઉડનું પોતાનું પ્રદાતા હોય છે અને ટેરાફોર્મ પોતે જ તેને તેના RPC પ્રોટોકોલ દ્વારા બે પ્રક્રિયાઓ વચ્ચે બોલાવે છે.
હવે મેં RPC કૉલ્સ દ્વારા સીધો ટેરાફોર્મ પ્રદાતાઓનો સંપર્ક કરવાનું નક્કી કર્યું. તે સુંદર રીતે બહાર આવ્યું અને ટેરાફોર્મ પ્રદાતાઓને નવામાં બદલવા અને કોડ બદલ્યા વિના નવી સુવિધાઓ મેળવવાનું શક્ય બનાવ્યું. તે પણ તારણ આપે છે કે tfstate માં તમામ ક્ષેત્રો tf માં ન હોવા જોઈએ, પરંતુ તમે કેવી રીતે શોધી શકો છો? ફક્ત તમારા પ્રદાતાને આ વિશે પૂછો. પછી નિયમિત અભિવ્યક્તિઓને એસેમ્બલ કરવાની બીજી પુનરાવર્તિત પોર્નોગ્રાફી શરૂ થઈ, tfstate ની અંદર તમામ સ્તરે ઊંડાણપૂર્વક ક્ષેત્રો શોધવા.

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

અંતિમ

ટેરાફોમરનો ઉપયોગ કરીને, અમે બે વાદળોમાંથી tf + tfstate કોડની 500-700 હજાર રેખાઓ જનરેટ કરી. કોડ આઈડિયાઝ તરીકે શ્રેષ્ઠ ઈન્ફ્રાસ્ટ્રક્ચરની જેમ અમે લેગસી વસ્તુઓ લઈ શક્યા અને માત્ર ટેરાફોર્મ દ્વારા તેમને સ્પર્શ કરવાનું શરૂ કર્યું. જ્યારે તમે વિશાળ ક્લાઉડ લો અને તેને ટેરાફોર્મ વર્કર ફાઇલોના રૂપમાં ટીમ દ્વારા પ્રાપ્ત કરો ત્યારે તે માત્ર જાદુ છે. અને પછી grep/replace/git વગેરે.

મેં તેને કાંસકો કર્યો અને તેને ક્રમમાં મૂક્યો, પરવાનગી મળી. ગુરુવારે (02.05.19/XNUMX/XNUMX) દરેક માટે GitHub પર રિલીઝ. github.com/GoogleCloudPlatform/terraformer
ઓપનસ્ટૅક અને કુબરનેટ્સ માટે સપોર્ટ ઉમેરવા માટે 600 સ્ટાર્સ, 2 પુલ વિનંતીઓ પહેલેથી જ પ્રાપ્ત થઈ છે. સારો પ્રતિભાવ. સામાન્ય રીતે, પ્રોજેક્ટ લોકો માટે ઉપયોગી છે
હું દરેકને સલાહ આપું છું કે જેઓ ટેરાફોર્મ સાથે કામ કરવાનું શરૂ કરવા માંગે છે અને આ માટે બધું ફરીથી લખવાનું નથી.
મને વિનંતીઓ, મુદ્દાઓ, તારાઓ ખેંચવામાં આનંદ થશે.

ડેમો


સોર્સ: www.habr.com