ਟੈਰਾਫਾਰਮਰ - ਕੋਡ ਟੂ ਬੁਨਿਆਦੀ ਢਾਂਚਾ

ਮੈਂ ਤੁਹਾਨੂੰ ਨਵੇਂ CLI ਟੂਲ ਬਾਰੇ ਦੱਸਣਾ ਚਾਹਾਂਗਾ ਜੋ ਮੈਂ ਇੱਕ ਪੁਰਾਣੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਲਿਖਿਆ ਸੀ।

ਸਮੱਸਿਆ

ਟੈਰਾਫਾਰਮ ਲੰਬੇ ਸਮੇਂ ਤੋਂ Devops/Cloud/IT ਭਾਈਚਾਰੇ ਵਿੱਚ ਇੱਕ ਮਿਆਰ ਰਿਹਾ ਹੈ। ਕੋਡ ਦੇ ਰੂਪ ਵਿੱਚ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਚੀਜ਼ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਅਤੇ ਉਪਯੋਗੀ ਹੈ. ਟੈਰਾਫਾਰਮ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਖੁਸ਼ੀਆਂ ਦੇ ਨਾਲ-ਨਾਲ ਬਹੁਤ ਸਾਰੇ ਕਾਂਟੇ, ਤਿੱਖੇ ਚਾਕੂ ਅਤੇ ਰੈਕ ਹਨ।
ਟੈਰਾਫਾਰਮ ਨਾਲ ਨਵੀਆਂ ਚੀਜ਼ਾਂ ਬਣਾਉਣਾ ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਦਾ ਪ੍ਰਬੰਧਨ, ਬਦਲਣਾ ਜਾਂ ਮਿਟਾਉਣਾ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਹੈ। ਉਹਨਾਂ ਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਕੋਲ ਕਲਾਉਡ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ਾਲ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਹੈ ਅਤੇ ਟੈਰਾਫਾਰਮ ਦੁਆਰਾ ਨਹੀਂ ਬਣਾਇਆ ਗਿਆ ਹੈ? ਪੂਰੇ ਕਲਾਉਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣਾ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਉਣਾ ਕਿਸੇ ਤਰ੍ਹਾਂ ਮਹਿੰਗਾ ਅਤੇ ਅਸੁਰੱਖਿਅਤ ਹੈ।
ਮੈਨੂੰ 2 ਨੌਕਰੀਆਂ 'ਤੇ ਇਸ ਸਮੱਸਿਆ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ, ਸਭ ਤੋਂ ਸਰਲ ਉਦਾਹਰਣ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਸਭ ਕੁਝ ਟੇਰਾਫਾਰਮ ਫਾਈਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਗਿਟ ਵਿੱਚ ਹੋਵੇ, ਪਰ ਤੁਹਾਡੇ ਕੋਲ 250+ ਬਾਲਟੀਆਂ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਹੱਥਾਂ ਨਾਲ ਟੈਰਾਫਾਰਮ ਵਿੱਚ ਲਿਖਣਾ ਬਹੁਤ ਹੈ।
ਹਨ ਮੁੱਦੇ ਟੈਰਾਫੌਮ ਵਿੱਚ 2014 ਤੋਂ ਜੋ ਕਿ 2016 ਵਿੱਚ ਇਸ ਉਮੀਦ ਨਾਲ ਬੰਦ ਕਰ ਦਿੱਤਾ ਗਿਆ ਸੀ ਕਿ ਆਯਾਤ ਹੋਵੇਗਾ।

ਆਮ ਤੌਰ 'ਤੇ, ਸਭ ਕੁਝ ਸਿਰਫ ਸੱਜੇ ਤੋਂ ਖੱਬੇ ਤੱਕ ਤਸਵੀਰ ਵਿੱਚ ਹੈ

ਚੇਤਾਵਨੀਆਂ: ਲੇਖਕ ਆਪਣੀ ਅੱਧੀ ਜ਼ਿੰਦਗੀ ਰੂਸ ਵਿੱਚ ਨਹੀਂ ਰਹਿੰਦਾ ਅਤੇ ਰੂਸੀ ਵਿੱਚ ਬਹੁਤ ਘੱਟ ਲਿਖਦਾ ਹੈ। ਸਪੈਲਿੰਗ ਗਲਤੀਆਂ ਤੋਂ ਸਾਵਧਾਨ ਰਹੋ।

ਹੱਲ

1. AWS ਲਈ ਇੱਕ ਤਿਆਰ-ਬਣਾਇਆ ਅਤੇ ਪੁਰਾਣਾ ਹੱਲ ਹੈ terraforming. ਜਦੋਂ ਮੈਂ ਇਸ ਰਾਹੀਂ ਆਪਣੀਆਂ 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 ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰੀਏ ?? ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ 'ਟੇਰਾਫਾਰਮ ਰਿਫਰੇਸ਼' ਕਮਾਂਡ ਬਚਾਅ ਲਈ ਆਈ। terraform ਸਾਰੇ ਸਰੋਤਾਂ ਨੂੰ tfstate ਵਿੱਚ ਲੈਂਦਾ ਹੈ ਅਤੇ, ID ਦੁਆਰਾ, ਉਹਨਾਂ 'ਤੇ ਡਾਟਾ ਕੱਢਦਾ ਹੈ ਅਤੇ tfstate ਨੂੰ ਸਭ ਕੁਝ ਲਿਖਦਾ ਹੈ। ਯਾਨੀ, ਸਿਰਫ਼ ਨਾਮਾਂ ਅਤੇ ID ਦੇ ਨਾਲ ਇੱਕ ਖਾਲੀ tfstate ਬਣਾਓ, `terraform refresh` ਚਲਾਓ ਅਤੇ ਫਿਰ ਸਾਨੂੰ ਪੂਰੀ tfstate ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ। ਹੂਰੇ!
ਆਉ ਹੁਣ tfstate ਨੂੰ 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