ಹಳೆಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಾನು ಬರೆದ ಹೊಸ CLI ಉಪಕರಣದ ಬಗ್ಗೆ ನಾನು ನಿಮಗೆ ಹೇಳಲು ಬಯಸುತ್ತೇನೆ.
ಸಮಸ್ಯೆಯನ್ನು
Devops/Cloud/IT ಸಮುದಾಯದಲ್ಲಿ ಟೆರ್ರಾಫಾರ್ಮ್ ಬಹಳ ಹಿಂದಿನಿಂದಲೂ ಪ್ರಮಾಣಿತವಾಗಿದೆ. ಮೂಲಸೌಕರ್ಯವನ್ನು ಕೋಡ್‌ನಂತೆ ವ್ಯವಹರಿಸಲು ವಿಷಯವು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ ಮತ್ತು ಉಪಯುಕ್ತವಾಗಿದೆ. ಟೆರ್ರಾಫಾರ್ಮ್‌ನಲ್ಲಿ ಅನೇಕ ಡಿಲೈಟ್‌ಗಳು ಮತ್ತು ಅನೇಕ ಫೋರ್ಕ್‌ಗಳು, ಚೂಪಾದ ಚಾಕುಗಳು ಮತ್ತು ರೇಕ್‌ಗಳು ಇವೆ.
ಟೆರಾಫಾರ್ಮ್‌ನೊಂದಿಗೆ ಹೊಸ ವಿಷಯಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ನಿರ್ವಹಿಸಲು, ಬದಲಾಯಿಸಲು ಅಥವಾ ಅಳಿಸಲು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ. ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಬೃಹತ್ ಮೂಲಸೌಕರ್ಯವನ್ನು ಹೊಂದಿರುವವರು ಮತ್ತು ಟೆರ್ರಾಫಾರ್ಮ್ ಮೂಲಕ ರಚಿಸದವರು ಏನು ಮಾಡಬೇಕು? ಸಂಪೂರ್ಣ ಮೋಡವನ್ನು ಪುನಃ ಬರೆಯುವುದು ಮತ್ತು ಮರುಸೃಷ್ಟಿಸುವುದು ಹೇಗಾದರೂ ದುಬಾರಿ ಮತ್ತು ಅಸುರಕ್ಷಿತವಾಗಿದೆ.
ನಾನು 2 ಉದ್ಯೋಗಗಳಲ್ಲಿ ಈ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿದ್ದೇನೆ, ಸರಳವಾದ ಉದಾಹರಣೆಯೆಂದರೆ ನೀವು ಎಲ್ಲವನ್ನೂ ಟೆರಾಫಾರ್ಮ್ ಫೈಲ್‌ಗಳ ರೂಪದಲ್ಲಿ Git ನಲ್ಲಿ ಇರಬೇಕೆಂದು ಬಯಸಿದಾಗ, ಆದರೆ ನೀವು 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 ಅನ್ನು ಹೇಗೆ ಪಡೆಯುವುದು ?? ಇಲ್ಲಿಯೇ `ಟೆರಾಫಾರ್ಮ್ ರಿಫ್ರೆಶ್~ ಆಜ್ಞೆಯು ನೆರವಿಗೆ ಬಂದಿತು. terraform ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು tfstate ನಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ID ಮೂಲಕ, ಅವುಗಳಲ್ಲಿರುವ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ ಮತ್ತು tfstate ಗೆ ಎಲ್ಲವನ್ನೂ ಬರೆಯುತ್ತದೆ. ಅಂದರೆ, ಕೇವಲ ಹೆಸರುಗಳು ಮತ್ತು ID ಗಳೊಂದಿಗೆ ಖಾಲಿ tfstate ಅನ್ನು ರಚಿಸಿ, `terraform refresh` ಅನ್ನು ರನ್ ಮಾಡಿ ಮತ್ತು ನಂತರ ನಾವು ಪೂರ್ಣ tfstates ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಹುರ್ರೇ!
ಈಗ 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 ಪ್ರೋಟೋಕಾಲ್ ಮೂಲಕ ಮಾತ್ರ ಅವುಗಳನ್ನು ಕರೆಯುತ್ತದೆ.
ಈಗ ನಾನು ಆರ್‌ಪಿಸಿ ಕರೆಗಳ ಮೂಲಕ ನೇರವಾಗಿ ಟೆರಾಫಾರ್ಮ್ ಪೂರೈಕೆದಾರರನ್ನು ಸಂಪರ್ಕಿಸಲು ನಿರ್ಧರಿಸಿದೆ. ಇದು ಸುಂದರವಾಗಿ ಹೊರಹೊಮ್ಮಿತು ಮತ್ತು ಟೆರಾಫಾರ್ಮ್ ಪೂರೈಕೆದಾರರನ್ನು ಹೊಸದಕ್ಕೆ ಬದಲಾಯಿಸಲು ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸದೆ ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಾಗಿಸಿತು. tfstate ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಕ್ಷೇತ್ರಗಳು tf ನಲ್ಲಿ ಇರಬಾರದು ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ, ಆದರೆ ನೀವು ಹೇಗೆ ಕಂಡುಹಿಡಿಯಬಹುದು? ಇದರ ಬಗ್ಗೆ ನಿಮ್ಮ ಪೂರೈಕೆದಾರರನ್ನು ಕೇಳಿ. ನಂತರ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಜೋಡಿಸುವ ಮತ್ತೊಂದು ಪುನರಾವರ್ತಿತ ಅಶ್ಲೀಲತೆ ಪ್ರಾರಂಭವಾಯಿತು, ಆಳದಲ್ಲಿ ಎಲ್ಲಾ ಹಂತಗಳಲ್ಲಿ tfstate ಒಳಗೆ ಕ್ಷೇತ್ರಗಳನ್ನು ಹುಡುಕುತ್ತದೆ.
ಕೊನೆಯಲ್ಲಿ, ನಾವು ಎಲ್ಲಾ ಟೆರಾಫಾರ್ಮ್ ಪೂರೈಕೆದಾರರಿಗೆ ಸಾಮಾನ್ಯ ಮೂಲಸೌಕರ್ಯವನ್ನು ಹೊಂದಿರುವ ಉಪಯುಕ್ತ CLI ಉಪಕರಣವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ ಮತ್ತು ನೀವು ಸುಲಭವಾಗಿ ಹೊಸದನ್ನು ಸೇರಿಸಬಹುದು. ಅಲ್ಲದೆ, ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸೇರಿಸಲು ಸ್ವಲ್ಪ ಕೋಡ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಜೊತೆಗೆ ಸಂಪನ್ಮೂಲಗಳ ನಡುವಿನ ಸಂಪರ್ಕಗಳಂತಹ ಎಲ್ಲಾ ರೀತಿಯ ಗುಡಿಗಳು. ಸಹಜವಾಗಿ, ಎಲ್ಲವನ್ನೂ ವಿವರಿಸಲಾಗದ ಹಲವಾರು ವಿಭಿನ್ನ ಸಮಸ್ಯೆಗಳಿವೆ.
ನಾನು ಪ್ರಾಣಿಗೆ ಟೆರಾಫೋಮರ್ ಎಂದು ಹೆಸರಿಸಿದೆ.
ಅಂತಿಮ
ಟೆರ್ರಾಫೋಮರ್ ಬಳಸಿ, ನಾವು ಎರಡು ಮೋಡಗಳಿಂದ 500-700 ಸಾವಿರ ಸಾಲುಗಳ tf + tfstate ಕೋಡ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ. ನಾವು ಪರಂಪರೆಯ ವಿಷಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಮತ್ತು ಟೆರಾಫಾರ್ಮ್ ಮೂಲಕ ಅವುಗಳನ್ನು ಸ್ಪರ್ಶಿಸಲು ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾಯಿತು, ಉತ್ತಮ ಮೂಲಸೌಕರ್ಯದಲ್ಲಿ ಕೋಡ್ ಕಲ್ಪನೆಗಳಂತೆ. ನೀವು ಬೃಹತ್ ಮೋಡವನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಟೆರಾಫಾರ್ಮ್ ವರ್ಕರ್ ಫೈಲ್‌ಗಳ ರೂಪದಲ್ಲಿ ತಂಡದ ಮೂಲಕ ಸ್ವೀಕರಿಸಿದಾಗ ಅದು ಕೇವಲ ಮ್ಯಾಜಿಕ್ ಆಗಿದೆ. ತದನಂತರ grep/replace/git ಹೀಗೆ.
ನಾನು ಅದನ್ನು ಬಾಚಿಕೊಂಡು ಕ್ರಮವಾಗಿ ಹಾಕಿದೆ, ಅನುಮತಿ ಪಡೆದುಕೊಂಡೆ. ಗುರುವಾರ (02.05.19/XNUMX/XNUMX) ಎಲ್ಲರಿಗೂ GitHub ನಲ್ಲಿ ಬಿಡುಗಡೆ ಮಾಡಲಾಗಿದೆ.
ಈಗಾಗಲೇ 600 ಸ್ಟಾರ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಲಾಗಿದೆ, ಓಪನ್‌ಸ್ಟಾಕ್ ಮತ್ತು ಕುಬರ್ನೆಟ್‌ಗಳಿಗೆ ಬೆಂಬಲವನ್ನು ಸೇರಿಸಲು 2 ಪುಲ್ ವಿನಂತಿಗಳು. ಉತ್ತಮ ಪ್ರತಿಕ್ರಿಯೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಯೋಜನೆಯು ಜನರಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ
ಟೆರ್ರಾಫಾರ್ಮ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಬಯಸುವ ಎಲ್ಲರಿಗೂ ನಾನು ಸಲಹೆ ನೀಡುತ್ತೇನೆ ಮತ್ತು ಇದಕ್ಕಾಗಿ ಎಲ್ಲವನ್ನೂ ಪುನಃ ಬರೆಯಬೇಡಿ.
ವಿನಂತಿಗಳು, ಸಮಸ್ಯೆಗಳು, ನಕ್ಷತ್ರಗಳನ್ನು ಎಳೆಯಲು ನನಗೆ ಸಂತೋಷವಾಗುತ್ತದೆ.
ಡೆಮೊ
ಮೂಲ: www.habr.com