AWS ಆಟೊಮೇಷನ್‌ನ ಶಕ್ತಿಯನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ. ಈ ಮಾರ್ಗದರ್ಶಿ Boto3 ಸೆಟಪ್, ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು, S3, EC2, Lambda ಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಜಾಗತಿಕ ತಂಡಗಳಿಗೆ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಪೈಥಾನ್‌ನೊಂದಿಗೆ AWS ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ: ಕ್ಲೌಡ್ ಸೇವಾ ಏಕೀಕರಣಕ್ಕಾಗಿ Boto3 SDK ಯ ಆಳವಾದ ಅವಲೋಕನ
ಕ್ಲೌಡ್ ಕಂಪ್ಯೂಟಿಂಗ್ ಜಗತ್ತಿನಲ್ಲಿ, ಅಮೆಜಾನ್ ವೆಬ್ ಸರ್ವಿಸಸ್ (AWS) ಜಾಗತಿಕ ನಾಯಕನಾಗಿ ನಿಂತಿದೆ, ವಿಶಾಲವಾದ ಮತ್ತು ನಿರಂತರವಾಗಿ ವಿಸ್ತರಿಸುತ್ತಿರುವ ಸೇವೆಗಳನ್ನು ನೀಡುತ್ತಿದೆ. ಡೆವಲಪರ್‌ಗಳು, DevOps ಇಂಜಿನಿಯರ್‌ಗಳು ಮತ್ತು ಸಿಸ್ಟಮ್ ಆರ್ಕಿಟೆಕ್ಟ್‌ಗಳಿಗೆ, ಈ ಸೇವೆಗಳೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ಆಗಿ ಸಂವಹನ ಮಾಡುವುದು ಕೇವಲ ಅನುಕೂಲವಲ್ಲ - ಇದೊಂದು ಅವಶ್ಯಕತೆ. ಸ್ಕೇಲೆಬಲ್, ಸ್ಥಿತಿಸ್ಥಾಪಕ ಮತ್ತು ಸಮರ್ಥ ಕ್ಲೌಡ್ ಮೂಲಸೌಕರ್ಯವನ್ನು ನಿರ್ವಹಿಸಲು ಆಟೊಮೇಷನ್ ಪ್ರಮುಖವಾಗಿದೆ. ಇಲ್ಲೇ Boto3, ಪೈಥಾನ್‌ಗಾಗಿ ಅಧಿಕೃತ AWS SDK, ನಿಮ್ಮ ಸಾಧನ ಸಂಗ್ರಹದಲ್ಲಿ ಅನಿವಾರ್ಯ ಸಾಧನವಾಗುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಇದು Boto3 ಯ ಆಳವಾದ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಾವು ಮೂಲಭೂತ ವಿಷಯಗಳಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಪ್ರಮುಖ AWS ಸೇವೆಗಳೊಂದಿಗೆ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳ ಮೂಲಕ ಸಾಗಿ, ಮತ್ತು ಸುಧಾರಿತ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ನೀವು ಸರಳ ಕಾರ್ಯವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತಿರಲಿ ಅಥವಾ ಸಂಕೀರ್ಣ, ಕ್ಲೌಡ್-ನೇಟಿವ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, Boto3 ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ ಪಡೆಯುವುದು AWS ನ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ನಿಮಗೆ ಅಧಿಕಾರ ನೀಡುತ್ತದೆ.
Boto3 ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು: AWS ಆಟೊಮೇಷನ್‌ಗೆ ನಿಮ್ಮ ಮೊದಲ ಹೆಜ್ಜೆಗಳು
ನಾವು ಯಾವುದೇ ಕೋಡ್ ಬರೆಯುವ ಮೊದಲು, ನಾವು ಸುರಕ್ಷಿತ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ. AWS ನೊಂದಿಗಿನ ನಿಮ್ಮ ಸಂವಹನಗಳು ಯಶಸ್ವಿ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಆರಂಭಿಕ ಸೆಟಪ್ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಜಾಗತಿಕ ಅಭಿವೃದ್ಧಿ ಪರಿಸರಕ್ಕೆ ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು
- ಪೈಥಾನ್ ಇನ್‌ಸ್ಟಾಲೇಶನ್: Boto3 ಒಂದು ಪೈಥಾನ್ ಲೈಬ್ರರಿಯಾಗಿದೆ, ಆದ್ದರಿಂದ ನಿಮಗೆ ಪೈಥಾನ್ ಇನ್‌ಸ್ಟಾಲ್ ಆಗಿರಬೇಕು. ಇದು ಹಲವಾರು ಪೈಥಾನ್ ಆವೃತ್ತಿಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ನಾವು ಪೈಥಾನ್ 3 ರ ಇತ್ತೀಚಿನ ಸ್ಥಿರ ಆವೃತ್ತಿಯನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ಪೈಥಾನ್‌ನ ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸ್ವಭಾವವು ಪ್ರಪಂಚದಾದ್ಯಂತ ಹಂಚಿಹೋಗಿರುವ ತಂಡಗಳಿಗೆ ಅತ್ಯುತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ.
- ಒಂದು AWS ಖಾತೆ: ನಿಮ್ಮ ಬಳಿ ಈಗಾಗಲೇ ಇಲ್ಲದಿದ್ದರೆ, ನೀವು AWS ಖಾತೆಗಾಗಿ ಸೈನ್ ಅಪ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯು ಸಾರ್ವತ್ರಿಕವಾಗಿದೆ ಮತ್ತು ಅನೇಕ ಸೇವೆಗಳಿಗೆ ಉಚಿತ ಶ್ರೇಣಿಗೆ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಕಲಿಕೆ ಮತ್ತು ಪ್ರಯೋಗಕ್ಕೆ ಪರಿಪೂರ್ಣವಾಗಿದೆ.
- AWS ರೀಜನ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: AWS ಸೇವೆಗಳನ್ನು ವಿಶ್ವಾದ್ಯಂತ ಡೇಟಾ ಸೆಂಟರ್‌ಗಳಲ್ಲಿ ಹೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ, ಇವುಗಳನ್ನು ಭೌಗೋಳಿಕ ರೀಜನ್‌ಗಳಾಗಿ (ಉದಾಹರಣೆಗೆ, `us-east-1`, `eu-west-2`, `ap-southeast-1`) ಆಯೋಜಿಸಲಾಗಿದೆ. ಸರಿಯಾದ ರೀಜನ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಲೇಟೆನ್ಸಿ, ಡೇಟಾ ಸಾರ್ವಭೌಮತ್ವ ಮತ್ತು ವೆಚ್ಚಕ್ಕಾಗಿ ನಿರ್ಣಾಯಕವಾಗಿದೆ. Boto3 ಬಳಸುವಾಗ, ನೀವು ಯಾವ ರೀಜನ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಬಯಸುತ್ತೀರಿ ಎಂಬುದನ್ನು ನೀವು ಆಗಾಗ್ಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗುತ್ತದೆ.
ಇನ್‌ಸ್ಟಾಲೇಶನ್ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್: ಒಂದು ಸುರಕ್ಷಿತ ಅಡಿಪಾಯ
ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು ಸಿದ್ಧವಾದ ನಂತರ, Boto3 ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡೋಣ ಮತ್ತು ನಿಮ್ಮ AWS ಖಾತೆಗೆ ಸುರಕ್ಷಿತವಾಗಿ ಸಂಪರ್ಕಿಸಲು ಅದನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡೋಣ.
1. Boto3 ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುವುದು
ಪೈಥಾನ್‌ನ ಪ್ಯಾಕೇಜ್ ಇನ್‌ಸ್ಟಾಲರ್ ಆದ `pip` ಬಳಸಿ ಇನ್‌ಸ್ಟಾಲೇಶನ್ ಸರಳವಾಗಿದೆ. ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ಅಥವಾ ಕಮಾಂಡ್ ಪ್ರಾಂಪ್ಟ್ ತೆರೆಯಿರಿ ಮತ್ತು ರನ್ ಮಾಡಿ:
pip install boto3
2. AWS ಕ್ರೆಡೆನ್ಶಿಯಲ್‌ಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು
ಇದು ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ಹಂತ. ನಿಮ್ಮ AWS ಕ್ರೆಡೆನ್ಶಿಯಲ್‌ಗಳನ್ನು (ಆಕ್ಸೆಸ್ ಕೀ ಐಡಿ ಮತ್ತು ಸೀಕ್ರೆಟ್ ಆಕ್ಸೆಸ್ ಕೀ) ನೇರವಾಗಿ ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಎಂದಿಗೂ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಬಾರದು. ಇದು ಒಂದು ದೊಡ್ಡ ಭದ್ರತಾ ಅಪಾಯ. ಶಿಫಾರಸು ಮಾಡಲಾದ ವಿಧಾನವೆಂದರೆ AWS ಕಮಾಂಡ್ ಲೈನ್ ಇಂಟರ್ಫೇಸ್ (CLI) ಬಳಸಿ ಅವುಗಳನ್ನು ಸುರಕ್ಷಿತ ಸ್ಥಳದಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು.
ಮೊದಲಿಗೆ, AWS CLI ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ (ನೀವು ಈಗಾಗಲೇ ಮಾಡದಿದ್ದರೆ). ನಂತರ, ಈ ಕೆಳಗಿನ ಕಮಾಂಡ್ ಅನ್ನು ರನ್ ಮಾಡಿ:
aws configure
CLIಯು ನಿಮ್ಮಿಂದ ನಾಲ್ಕು ಮಾಹಿತಿಗಳನ್ನು ಕೇಳುತ್ತದೆ:
- AWS Access Key ID: ನಿಮ್ಮ ಅನನ್ಯ ಗುರುತಿಸುವಿಕೆ.
- AWS Secret Access Key: ನಿಮ್ಮ ರಹಸ್ಯ ಪಾಸ್‌ವರ್ಡ್. ಇದನ್ನು ಯಾವುದೇ ಪಾಸ್‌ವರ್ಡ್‌ನಂತೆ ಪರಿಗಣಿಸಿ.
- Default region name: ನಿಮ್ಮ ಕೋಡ್ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಸಂಪರ್ಕಿಸುವ AWS ರೀಜನ್ (ಉದಾ., `us-west-2`).
- Default output format: ಸಾಮಾನ್ಯವಾಗಿ `json`.
ಈ ಕಮಾಂಡ್ ನಿಮ್ಮ ಕ್ರೆಡೆನ್ಶಿಯಲ್‌ಗಳನ್ನು `~/.aws/credentials` ನಲ್ಲಿರುವ ಫೈಲ್‌ಗಳಲ್ಲಿ ಮತ್ತು ನಿಮ್ಮ ಡೀಫಾಲ್ಟ್ ರೀಜನ್/ಔಟ್‌ಪುಟ್ ಫಾರ್ಮ್ಯಾಟ್ ಅನ್ನು `~/.aws/config` ನಲ್ಲಿ ಸುರಕ್ಷಿತವಾಗಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. Boto3 ಈ ಫೈಲ್‌ಗಳನ್ನು ಹುಡುಕಲು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ತಿಳಿದಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಕ್ರೆಡೆನ್ಶಿಯಲ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ. ಈ ವಿಧಾನವು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪೋರ್ಟಬಲ್ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿರಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಸೂಕ್ಷ್ಮ ಕೀಗಳನ್ನು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಲಾಜಿಕ್‌ನಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿ ಇರಿಸಲಾಗುತ್ತದೆ.
Boto3 ಯ ಪ್ರಮುಖ ಘಟಕಗಳು: ಕ್ಲೈಂಟ್‌ಗಳು ಮತ್ತು ರಿಸೋರ್ಸ್‌ಗಳು
Boto3 AWS ಸೇವೆಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಎರಡು ವಿಭಿನ್ನ ಮಾರ್ಗಗಳನ್ನು ನೀಡುತ್ತದೆ, ಅವನ್ನು ಕ್ಲೈಂಟ್‌ಗಳು ಮತ್ತು ರಿಸೋರ್ಸ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಓದಬಲ್ಲ ಕೋಡ್ ಬರೆಯಲು ಇವುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.
ಎರಡು ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಇವುಗಳನ್ನು ಎರಡು ವಿಭಿನ್ನ ಹಂತದ ಸಂವಹನ ಎಂದು ಭಾವಿಸಿ:
- ಕ್ಲೈಂಟ್‌ಗಳು (ಕಡಿಮೆ-ಮಟ್ಟ): ಆಧಾರವಾಗಿರುವ AWS ಸೇವಾ API ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ನೇರವಾದ, ಒಂದಕ್ಕೊಂದು ಮ್ಯಾಪಿಂಗ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ. ಸೇವೆಯ ಮೇಲಿನ ಪ್ರತಿಯೊಂದು ಸಂಭಾವ್ಯ ಕ್ರಿಯೆಯು ಅದರ ಕ್ಲೈಂಟ್ ಮೂಲಕ ಲಭ್ಯವಿದೆ. ಪ್ರತಿಕ್ರಿಯೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಡಿಕ್ಷನರಿಗಳಾಗಿರುತ್ತವೆ, API ನಿಂದ ಬರುವ ರಾ JSON ಪ್ರತಿಕ್ರಿಯೆಯಂತೆಯೇ.
- ರಿಸೋರ್ಸ್‌ಗಳು (ಉನ್ನತ-ಮಟ್ಟ): ಹೆಚ್ಚು ಅಮೂರ್ತ, ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ. ಕೇವಲ ಮೆಥಡ್‌ಗಳನ್ನು ಕರೆಯುವ ಬದಲು, ನೀವು ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಕ್ರಿಯೆಗಳನ್ನು ಹೊಂದಿರುವ 'ರಿಸೋರ್ಸ್' ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತೀರಿ. ಉದಾಹರಣೆಗೆ, ನೀವು `S3.Bucket` ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹೊಂದಿರಬಹುದು, ಅದು ಹೆಸರು ಗುಣಲಕ್ಷಣ ಮತ್ತು `delete()` ಕ್ರಿಯೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.
ಕ್ಲೈಂಟ್ API: ಕಡಿಮೆ-ಮಟ್ಟದ, ನೇರ ಸೇವಾ ಪ್ರವೇಶ
ಕ್ಲೈಂಟ್‌ಗಳು Boto3 ಯ ಮೂಲಭೂತ ಪದರವಾಗಿದೆ. ಅವುಗಳನ್ನು ನೇರವಾಗಿ ಸೇವೆಯ API ವ್ಯಾಖ್ಯಾನ ಫೈಲ್‌ನಿಂದ ರಚಿಸಲಾಗುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಅವು ಯಾವಾಗಲೂ ಅಪ್-ಟು-ಡೇಟ್ ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿರುತ್ತವೆ.
ಕ್ಲೈಂಟ್ ಅನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು:
- ರಿಸೋರ್ಸ್ API ಮೂಲಕ ಲಭ್ಯವಿಲ್ಲದ ಸೇವಾ ಕಾರ್ಯಾಚರಣೆಗೆ ನಿಮಗೆ ಪ್ರವೇಶ ಬೇಕಾದಾಗ.
- ನೀವು ಡಿಕ್ಷನರಿ-ಆಧಾರಿತ ಪ್ರತಿಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಆದ್ಯತೆ ನೀಡಿದಾಗ.
- API ಕರೆಗಳ ಮೇಲೆ ನಿಮಗೆ ಸಂಪೂರ್ಣ ಸೂಕ್ಷ್ಮ-ಮಟ್ಟದ ನಿಯಂತ್ರಣ ಬೇಕಾದಾಗ.
ಉದಾಹರಣೆ: ಕ್ಲೈಂಟ್ ಬಳಸಿ S3 ಬಕೆಟ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು
import boto3
# S3 ಕ್ಲೈಂಟ್ ಅನ್ನು ರಚಿಸಿ
s3_client = boto3.client('s3')
# list_buckets ಮೆಥಡ್ ಅನ್ನು ಕಾಲ್ ಮಾಡಿ
response = s3_client.list_buckets()
# ಬಕೆಟ್ ಹೆಸರುಗಳನ್ನು ಪ್ರಿಂಟ್ ಮಾಡಿ
print('Existing buckets:')
for bucket in response['Buckets']:
print(f' {bucket["Name"]}')
ಬಕೆಟ್ ಹೆಸರುಗಳನ್ನು ಪಡೆಯಲು ನಾವು `response` ಡಿಕ್ಷನರಿಯನ್ನು ಹೇಗೆ ಪಾರ್ಸ್ ಮಾಡಬೇಕಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ರಿಸೋರ್ಸ್ API: ಒಂದು ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ವಿಧಾನ
ರಿಸೋರ್ಸ್‌ಗಳು AWS ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಹೆಚ್ಚು 'ಪೈಥಾನಿಕ್' ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಅವು ಕೆಲವು ಆಧಾರವಾಗಿರುವ ನೆಟ್‌ವರ್ಕ್ ಕರೆಗಳನ್ನು ಮರೆಮಾಡುತ್ತವೆ ಮತ್ತು ಸ್ವಚ್ಛವಾದ, ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ.
ರಿಸೋರ್ಸ್ ಅನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು:
- ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ ಕೋಡ್‌ಗಾಗಿ.
- AWS ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೇಲೆ ಸಾಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ.
- ನೀವು ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಶೈಲಿಯನ್ನು ಆದ್ಯತೆ ನೀಡಿದಾಗ.
ಉದಾಹರಣೆ: ರಿಸೋರ್ಸ್ ಬಳಸಿ S3 ಬಕೆಟ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು
import boto3
# S3 ರಿಸೋರ್ಸ್ ಅನ್ನು ರಚಿಸಿ
s3_resource = boto3.resource('s3')
# ಎಲ್ಲಾ ಬಕೆಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೂಲಕ ಇಟರೇಟ್ ಮಾಡಿ
print('Existing buckets:')
for bucket in s3_resource.buckets.all():
print(f' {bucket.name}')
ಈ ಕೋಡ್ ಹೆಚ್ಚು ಸ್ವಚ್ಛವಾಗಿದೆ ಎಂದು ವಾದಿಸಬಹುದು. ನಾವು ನೇರವಾಗಿ `bucket` ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೇಲೆ ಇಟರೇಟ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳ ಹೆಸರುಗಳನ್ನು `.name` ಗುಣಲಕ್ಷಣವನ್ನು ಬಳಸಿ ಪ್ರವೇಶಿಸುತ್ತೇವೆ.
ಕ್ಲೈಂಟ್ vs. ರಿಸೋರ್ಸ್: ನೀವು ಯಾವುದನ್ನು ಆರಿಸಬೇಕು?
ಇದಕ್ಕೆ ಒಂದೇ ಸರಿಯಾದ ಉತ್ತರವಿಲ್ಲ; ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯ ಮತ್ತು ವೈಯಕ್ತಿಕ ಆದ್ಯತೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಒಂದು ಉತ್ತಮ ನಿಯಮವೆಂದರೆ:
- ರಿಸೋರ್ಸ್‌ಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ: ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳಿಗಾಗಿ, ರಿಸೋರ್ಸ್ API ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
- ಶಕ್ತಿಗಾಗಿ ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ಬದಲಿಸಿ: ರಿಸೋರ್ಸ್ API ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ API ಕರೆ ಲಭ್ಯವಿಲ್ಲದಿದ್ದರೆ, ಅಥವಾ ನಿಮಗೆ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಮೇಲೆ ವಿವರವಾದ ನಿಯಂತ್ರಣ ಬೇಕಾದರೆ, ಕ್ಲೈಂಟ್ ಬಳಸಿ.
ನೀವು ಇವೆರಡನ್ನೂ ಮಿಶ್ರಣ ಮಾಡಬಹುದು. ರಿಸೋರ್ಸ್ ಆಬ್ಜೆಕ್ಟ್ `meta` ಗುಣಲಕ್ಷಣದ ಮೂಲಕ ಅದರ ಆಧಾರವಾಗಿರುವ ಕ್ಲೈಂಟ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ನೀಡುತ್ತದೆ (ಉದಾ., `s3_resource.meta.client`).
ಪ್ರಾಯೋಗಿಕ Boto3 ಕ್ರಿಯೆಯಲ್ಲಿ: ಪ್ರಮುಖ AWS ಸೇವೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು
ವಿಶ್ವಾದ್ಯಂತ ಸಂಸ್ಥೆಗಳು ಬಳಸುವ ಕೆಲವು ಸಾಮಾನ್ಯ AWS ಸೇವೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ಮೂಲಕ ಸಿದ್ಧಾಂತವನ್ನು ಆಚರಣೆಗೆ ತರೋಣ.
ಅಮೆಜಾನ್ S3 (ಸಿಂಪಲ್ ಸ್ಟೋರೇಜ್ ಸರ್ವಿಸ್): ಜಾಗತಿಕ ಡೇಟಾ ಹಬ್
S3 ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಸ್ಟೋರೇಜ್ ಸೇವೆಯಾಗಿದ್ದು, ಉದ್ಯಮ-ಪ್ರಮುಖ ಸ್ಕೇಲೆಬಿಲಿಟಿ, ಡೇಟಾ ಲಭ್ಯತೆ, ಭದ್ರತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀಡುತ್ತದೆ. ಇದು ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಡೇಟಾ ಸಂಗ್ರಹಣೆಯ ಬೆನ್ನೆಲುಬಾಗಿದೆ.
ಉದಾಹರಣೆ: ಒಂದು ಸಂಪೂರ್ಣ S3 ವರ್ಕ್‌ಫ್ಲೋ
import boto3
import uuid # ಅನನ್ಯ ಬಕೆಟ್ ಹೆಸರು ರಚಿಸಲು
# ಉನ್ನತ-ಮಟ್ಟದ ಇಂಟರ್ಫೇಸ್‌ಗಾಗಿ S3 ರಿಸೋರ್ಸ್ ಬಳಸಿ
s3 = boto3.resource('s3')
# ಬಕೆಟ್ ರಚಿಸುವ ರೀಜನ್ ಆಯ್ಕೆಮಾಡಿ
# ಗಮನಿಸಿ: S3 ಬಕೆಟ್ ಹೆಸರುಗಳು ಜಾಗತಿಕವಾಗಿ ಅನನ್ಯವಾಗಿರಬೇಕು!
region = 'us-east-1'
bucket_name = f'boto3-guide-unique-bucket-{uuid.uuid4()}'
file_name = 'hello.txt'
try:
# 1. ಬಕೆಟ್ ರಚಿಸಿ
print(f'Creating bucket: {bucket_name}...')
s3.create_bucket(
Bucket=bucket_name,
CreateBucketConfiguration={'LocationConstraint': region}
)
print('Bucket created successfully.')
# 2. ಫೈಲ್ ಅಪ್‌ಲೋಡ್ ಮಾಡಿ
print(f'Uploading {file_name} to {bucket_name}...')
bucket = s3.Bucket(bucket_name)
bucket.put_object(Key=file_name, Body=b'Hello, World from Boto3!')
print('File uploaded successfully.')
# 3. ಬಕೆಟ್‌ನಲ್ಲಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ
print(f'Listing objects in {bucket_name}:')
for obj in bucket.objects.all():
print(f' - {obj.key}')
# 4. ಫೈಲ್ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ
download_path = f'downloaded_{file_name}'
print(f'Downloading {file_name} to {download_path}...')
bucket.download_file(file_name, download_path)
print('File downloaded successfully.')
finally:
# 5. ಸ್ವಚ್ಛಗೊಳಿಸಿ: ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಮತ್ತು ನಂತರ ಬಕೆಟ್ ಅನ್ನು ಅಳಿಸಿ
print('Cleaning up resources...')
bucket = s3.Bucket(bucket_name)
# ಬಕೆಟ್ ಅಳಿಸುವ ಮೊದಲು ಎಲ್ಲಾ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಅಳಿಸುವುದು ಮುಖ್ಯ
bucket.objects.all().delete()
bucket.delete()
print(f'Bucket {bucket_name} and its contents have been deleted.')
ಅಮೆಜಾನ್ EC2 (ಎಲಾಸ್ಟಿಕ್ ಕಂಪ್ಯೂಟ್ ಕ್ಲೌಡ್): ವರ್ಚುವಲ್ ಸರ್ವರ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು
EC2 ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಸುರಕ್ಷಿತ, ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದಾದ ಕಂಪ್ಯೂಟ್ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದನ್ನು ಡೆವಲಪರ್‌ಗಳಿಗೆ ವೆಬ್-ಸ್ಕೇಲ್ ಕ್ಲೌಡ್ ಕಂಪ್ಯೂಟಿಂಗ್ ಅನ್ನು ಸುಲಭಗೊಳಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.
ಉದಾಹರಣೆ: EC2 ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಮತ್ತು ನಿರ್ವಹಿಸುವುದು
import boto3
import time
# EC2 ರಿಸೋರ್ಸ್ ಬಳಸಿ
ec2 = boto3.resource('ec2', region_name='us-west-2')
# ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ರೀಜನ್‌ನಲ್ಲಿ ಸೂಕ್ತವಾದ ಅಮೆಜಾನ್ ಲಿನಕ್ಸ್ 2 AMI ಅನ್ನು ಹುಡುಕಿ
# ಇತ್ತೀಚಿನ AMI ID ಪಡೆಯಲು ಕ್ಲೈಂಟ್ ಬಳಸಿ
ec2_client = boto3.client('ec2', region_name='us-west-2')
filters = [
{'Name': 'name', 'Values': ['amzn2-ami-hvm-*-x86_64-gp2']},
{'Name': 'state', 'Values': ['available']}
]
images = ec2_client.describe_images(Owners=['amazon'], Filters=filters)
ami_id = images['Images'][0]['ImageId']
print(f'Using AMI ID: {ami_id}')
# 1. ಹೊಸ t2.micro ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ (ಸಾಮಾನ್ಯವಾಗಿ ಉಚಿತ ಶ್ರೇಣಿಯಲ್ಲಿ)
instance = ec2.create_instances(
ImageId=ami_id,
InstanceType='t2.micro',
MinCount=1,
MaxCount=1,
TagSpecifications=[
{
'ResourceType': 'instance',
'Tags': [{'Key': 'Name', 'Value': 'Boto3-Guide-Instance'}]
}
]
)[0] # create_instances ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
print(f'Instance {instance.id} is launching...')
# 2. ಇನ್‌ಸ್ಟೆನ್ಸ್ 'running' ಸ್ಥಿತಿಗೆ ಬರುವವರೆಗೆ ಕಾಯಿರಿ
instance.wait_until_running()
print(f'Instance {instance.id} is now running.')
# ಪಬ್ಲಿಕ್ IP ವಿಳಾಸವನ್ನು ಪಡೆಯಲು ಇನ್‌ಸ್ಟೆನ್ಸ್ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮರುಲೋಡ್ ಮಾಡಿ
instance.reload()
print(f'Public IP Address: {instance.public_ip_address}')
# 3. ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ನಿಲ್ಲಿಸಿ
print(f'Stopping instance {instance.id}...')
instance.stop()
instance.wait_until_stopped()
print(f'Instance {instance.id} is stopped.')
# 4. ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ಟರ್ಮಿನೇಟ್ ಮಾಡಿ (ಅದನ್ನು ಶಾಶ್ವತವಾಗಿ ಅಳಿಸುತ್ತದೆ)
print(f'Terminating instance {instance.id}...')
instance.terminate()
instance.wait_until_terminated()
print(f'Instance {instance.id} has been terminated.')
AWS ಲ್ಯಾಂಬ್ಡಾ: ಸರ್ವರ್‌ಲೆಸ್ ಏಕೀಕರಣ
ಲ್ಯಾಂಬ್ಡಾ ಒಂದು ಸರ್ವರ್‌ಲೆಸ್ ಕಂಪ್ಯೂಟ್ ಸೇವೆಯಾಗಿದ್ದು, ಇದು ಸರ್ವರ್‌ಗಳನ್ನು ಒದಗಿಸದೆ ಅಥವಾ ನಿರ್ವಹಿಸದೆ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ನೀವು 200 ಕ್ಕೂ ಹೆಚ್ಚು AWS ಸೇವೆಗಳಿಂದ ಲ್ಯಾಂಬ್ಡಾ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಟ್ರಿಗರ್ ಮಾಡಬಹುದು ಅಥವಾ ಯಾವುದೇ ವೆಬ್ ಅಥವಾ ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ನೇರವಾಗಿ ಅವುಗಳನ್ನು ಕರೆಯಬಹುದು.
ಉದಾಹರಣೆ: ಲ್ಯಾಂಬ್ಡಾ ಫಂಕ್ಷನ್ ಅನ್ನು ಇನ್ವೋಕ್ ಮಾಡುವುದು
ಮೊದಲಿಗೆ, ನಿಮ್ಮ AWS ಖಾತೆಯಲ್ಲಿ ನಿಮಗೆ ಲ್ಯಾಂಬ್ಡಾ ಫಂಕ್ಷನ್ ಬೇಕು. ನೀವು `my-data-processor` ಎಂಬ ಸರಳ ಫಂಕ್ಷನ್ ಅನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ, ಅದು JSON ಪೇಲೋಡ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
import boto3
import json
# ಲ್ಯಾಂಬ್ಡಾ ಕ್ಲೈಂಟ್ ಬಳಸಿ
lambda_client = boto3.client('lambda', region_name='eu-central-1')
function_name = 'my-data-processor'
payload = {
'customer_id': '12345',
'transaction_amount': 99.99
}
try:
print(f'Invoking Lambda function: {function_name}')
response = lambda_client.invoke(
FunctionName=function_name,
InvocationType='RequestResponse', # ಸಿಂಕ್ರೊನಸ್ ಇನ್ವೊಕೇಶನ್
Payload=json.dumps(payload)
)
# ಪ್ರತಿಕ್ರಿಯೆ ಪೇಲೋಡ್ ಒಂದು ಸ್ಟ್ರೀಮಿಂಗ್ ಬಾಡಿಯಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಓದಿ ಡಿಕೋಡ್ ಮಾಡಬೇಕಾಗಿದೆ
response_payload = json.loads(response['Payload'].read().decode('utf-8'))
print('Lambda invocation successful.')
print(f'Status Code: {response["StatusCode"]}')
print(f'Response Payload: {response_payload}')
except lambda_client.exceptions.ResourceNotFoundException:
print(f'Error: Lambda function {function_name} not found.')
except Exception as e:
print(f'An error occurred: {e}')
ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಸುಧಾರಿತ Boto3 ಪರಿಕಲ್ಪನೆಗಳು
ನೀವು ಮೂಲಭೂತ ವಿಷಯಗಳೊಂದಿಗೆ ಆರಾಮದಾಯಕವಾದ ನಂತರ, ಸ್ಥಿತಿಸ್ಥಾಪಕ, ಸಮರ್ಥ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನೀವು Boto3 ಯ ಹೆಚ್ಚು ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು.
ದೋಷಗಳು ಮತ್ತು ಎಕ್ಸೆಪ್ಶನ್‌ಗಳನ್ನು ನಾಜೂಕಿನಿಂದ ನಿಭಾಯಿಸುವುದು
ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆಗಳು, ಅನುಮತಿ ದೋಷಗಳು, ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ರಿಸೋರ್ಸ್‌ಗಳು ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ವಿಫಲಗೊಳ್ಳಲು ಕಾರಣವಾಗಬಹುದು. ದೃಢವಾದ ಕೋಡ್ ಈ ದೋಷಗಳನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಮತ್ತು ನಿಭಾಯಿಸುತ್ತದೆ. Boto3 ಸೇವೆ-ನಿರ್ದಿಷ್ಟ ದೋಷಗಳಿಗಾಗಿ ಎಕ್ಸೆಪ್ಶನ್‌ಗಳನ್ನು ಎತ್ತುತ್ತದೆ, ಸಾಮಾನ್ಯವಾಗಿ `botocore.exceptions.ClientError` ನ ಉಪವರ್ಗಗಳು.
ನೀವು ಈ ಎಕ್ಸೆಪ್ಶನ್‌ಗಳನ್ನು ಹಿಡಿದು ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಯನ್ನು ನಿರ್ಧರಿಸಲು ದೋಷ ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸಬಹುದು.
import boto3
from botocore.exceptions import ClientError
s3_client = boto3.client('s3')
bucket_name = 'a-bucket-that-does-not-exist-12345'
try:
s3_client.head_bucket(Bucket=bucket_name)
print(f'Bucket "{bucket_name}" exists.')
except ClientError as e:
# ನಿರ್ದಿಷ್ಟ '404 Not Found' ದೋಷ ಕೋಡ್‌ಗಾಗಿ ಪರಿಶೀಲಿಸಿ
error_code = e.response['Error']['Code']
if error_code == '404':
print(f'Bucket "{bucket_name}" does not exist.')
elif error_code == '403':
print(f'Access denied. You do not have permission to access bucket "{bucket_name}".')
else:
print(f'An unexpected error occurred: {e}')
ವೇಟರ್ಸ್: ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದು
EC2 ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅಥವಾ S3 ಬಕೆಟ್ ರಚಿಸುವಂತಹ ಅನೇಕ AWS ಕಾರ್ಯಾಚರಣೆಗಳು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿರುತ್ತವೆ. API ಕರೆ ತಕ್ಷಣವೇ ಹಿಂತಿರುಗುತ್ತದೆ, ಆದರೆ ರಿಸೋರ್ಸ್ ಬಯಸಿದ ಸ್ಥಿತಿಯನ್ನು ತಲುಪಲು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಸಂಕೀರ್ಣ ಪೋಲಿಂಗ್ ಲೂಪ್‌ಗಳನ್ನು ಬರೆಯುವ ಬದಲು, ನೀವು Boto3 ಯ ಅಂತರ್ನಿರ್ಮಿತ 'ವೇಟರ್ಸ್' ಅನ್ನು ಬಳಸಬಹುದು.
ವೇಟರ್ ಒಂದು ರಿಸೋರ್ಸ್‌ನ ಸ್ಥಿತಿಯನ್ನು ನಿಯಮಿತ ಮಧ್ಯಂತರದಲ್ಲಿ ಪೋಲ್ ಮಾಡುತ್ತದೆ, ಅದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯನ್ನು ತಲುಪುವವರೆಗೆ ಅಥವಾ ಸಮಯ ಮೀರುವವರೆಗೆ.
# ಇದನ್ನು ಈಗಾಗಲೇ EC2 ಉದಾಹರಣೆಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗಿದೆ:
# ಇನ್‌ಸ್ಟೆನ್ಸ್ ಚಾಲನೆಯಾಗಲು ವೇಟರ್
instance.wait_until_running()
# S3 ಬಕೆಟ್ ಅಸ್ತಿತ್ವದಲ್ಲಿರಲು ವೇಟರ್
s3_client = boto3.client('s3')
waiter = s3_client.get_waiter('bucket_exists')
waiter.wait(Bucket='my-newly-created-bucket')
print('Bucket is now ready to use.')
ಪೇಜಿನೇಟರ್ಸ್: ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿಭಾಯಿಸುವುದು
ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಐಟಂಗಳನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದಾದ API ಕರೆಗಳು (S3 ಬಕೆಟ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು ಅಥವಾ ಎಲ್ಲಾ IAM ಬಳಕೆದಾರರನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು) ಆಗಾಗ್ಗೆ ಪೇಜಿನೇಟೆಡ್ ಆಗಿರುತ್ತವೆ. ಇದರರ್ಥ ನೀವು ಫಲಿತಾಂಶಗಳ 'ಪುಟ' ಮತ್ತು ಮುಂದಿನ ಪುಟವನ್ನು ವಿನಂತಿಸಲು 'ಟೋಕನ್' ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಈ ಟೋಕನ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುವುದು ಬೇಸರದ ಸಂಗತಿಯಾಗಬಹುದು.
ಪೇಜಿನೇಟರ್ಸ್ ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತವೆ, ಟೋಕನ್ ಲಾಜಿಕ್ ಅನ್ನು ನಿಮಗಾಗಿ ನಿಭಾಯಿಸುತ್ತವೆ, ಇದರಿಂದ ನೀವು ಎಲ್ಲಾ ಫಲಿತಾಂಶಗಳ ಮೇಲೆ ಮನಬಂದಂತೆ ಇಟರೇಟ್ ಮಾಡಬಹುದು.
import boto3
s3_client = boto3.client('s3')
# ಪೇಜಿನೇಟರ್ ರಚಿಸಿ
paginator = s3_client.get_paginator('list_objects_v2')
# ಎಲ್ಲಾ ಪುಟಗಳಿಗೆ ಇಟರೇಬಲ್ ಆಬ್ಜೆಕ್ಟ್ ಪಡೆಯಿರಿ
pages = paginator.paginate(Bucket='a-very-large-bucket')
object_count = 0
for page in pages:
if 'Contents' in page:
for obj in page['Contents']:
# print(obj['Key'])
object_count += 1
print(f'Total objects found: {object_count}')
ಜಾಗತಿಕ Boto3 ಅಭಿವೃದ್ಧಿಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕೋಡ್ ಬರೆಯುವುದು ಒಂದು ವಿಷಯ; ಸುರಕ್ಷಿತ, ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ವೆಚ್ಚ-ಪರಿಣಾಮಕಾರಿ ಕೋಡ್ ಬರೆಯುವುದು ಇನ್ನೊಂದು. ಉತ್ತಮ ಅಭ್ಯಾಸಗಳಿಗೆ ಬದ್ಧವಾಗಿರುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ತಂಡಗಳಿಗೆ.
ಭದ್ರತೆ
- ಕ್ರೆಡೆನ್ಶಿಯಲ್‌ಗಳನ್ನು ಎಂದಿಗೂ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಬೇಡಿ: ಇದನ್ನು ಅತಿಯಾಗಿ ಹೇಳಲಾಗುವುದಿಲ್ಲ. EC2 ಮತ್ತು ಲ್ಯಾಂಬ್ಡಾದಂತಹ ಸೇವೆಗಳಿಗೆ IAM ರೋಲ್‌ಗಳನ್ನು ಬಳಸಿ, ಇದು ತಾತ್ಕಾಲಿಕ, ಸ್ವಯಂಚಾಲಿತವಾಗಿ ತಿರುಗುವ ಕ್ರೆಡೆನ್ಶಿಯಲ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿಗಾಗಿ, AWS CLI ಮೂಲಕ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ `~/.aws/credentials` ಫೈಲ್ ಅನ್ನು ಬಳಸಿ.
- ಕನಿಷ್ಠ ಸವಲತ್ತುಗಳ ತತ್ವವನ್ನು ಅನ್ವಯಿಸಿ: ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುವ IAM ಬಳಕೆದಾರ ಅಥವಾ ರೋಲ್, ಅದು ನಿರ್ವಹಿಸಬೇಕಾದ ಕ್ರಿಯೆಗಳಿಗೆ ಮಾತ್ರ ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿರಬೇಕು. ಉದಾಹರಣೆಗೆ, S3 ಬಕೆಟ್‌ನಿಂದ ಮಾತ್ರ ಓದುವ ಸ್ಕ್ರಿಪ್ಟ್ `s3:PutObject` ಅಥವಾ `s3:DeleteObject` ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿರಬಾರದು.
ಕಾರ್ಯಕ್ಷಮತೆ
- ಕ್ಲೈಂಟ್/ರಿಸೋರ್ಸ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಮರುಬಳಸಿ: Boto3 ಕ್ಲೈಂಟ್ ಅಥವಾ ರಿಸೋರ್ಸ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವುದು ಕೆಲವು ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ದೀರ್ಘಕಾಲ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಅಥವಾ ಲ್ಯಾಂಬ್ಡಾ ಫಂಕ್ಷನ್‌ಗಳಲ್ಲಿ, ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಒಮ್ಮೆ ರಚಿಸಿ ಮತ್ತು ಅದನ್ನು ಅನೇಕ ಕರೆಗಳಾದ್ಯಂತ ಮರುಬಳಸಿ.
- ಪ್ರಾದೇಶಿಕ ಲೇಟೆನ್ಸಿಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ, ನಿಮ್ಮ Boto3 ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ನೀವು ಸಂವಹನ ನಡೆಸುತ್ತಿರುವ ಸೇವೆಗಳಿರುವ ಅದೇ AWS ರೀಜನ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಿ. ಉದಾಹರಣೆಗೆ, `eu-west-1` ನಲ್ಲಿರುವ ಇತರ ರಿಸೋರ್ಸ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು `eu-west-1` ನಲ್ಲಿನ EC2 ಇನ್‌ಸ್ಟೆನ್ಸ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಿ. ಇದು ನೆಟ್‌ವರ್ಕ್ ಲೇಟೆನ್ಸಿಯನ್ನು ನಾಟಕೀಯವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಕೋಡ್ ಗುಣಮಟ್ಟ ಮತ್ತು ನಿರ್ವಹಣೆ
- Boto3 ಕರೆಗಳನ್ನು ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮಾಡಿ: ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ನಾದ್ಯಂತ Boto3 ಕರೆಗಳನ್ನು ಹರಡಬೇಡಿ. ಅವುಗಳನ್ನು ನಿಮ್ಮ ಸ್ವಂತ ಫಂಕ್ಷನ್‌ಗಳು ಅಥವಾ ಕ್ಲಾಸ್‌ಗಳಲ್ಲಿ (ಉದಾ., `S3Manager` ಕ್ಲಾಸ್) ಸುತ್ತಿ. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಓದಲು, ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
- ಲಾಗಿಂಗ್ ಬಳಸಿ: `print()` ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳ ಬದಲು, ಪೈಥಾನ್‌ನ `logging` ಮಾಡ್ಯೂಲ್ ಬಳಸಿ. ಇದು ನಿಮಗೆ ವರ್ಬಾಸಿಟಿಯನ್ನು ನಿಯಂತ್ರಿಸಲು ಮತ್ತು ಔಟ್‌ಪುಟ್ ಅನ್ನು ಫೈಲ್‌ಗಳಿಗೆ ಅಥವಾ ಲಾಗಿಂಗ್ ಸೇವೆಗಳಿಗೆ ನಿರ್ದೇಶಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಪ್ರೊಡಕ್ಷನ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಅತ್ಯಗತ್ಯ.
ವೆಚ್ಚ ನಿರ್ವಹಣೆ
- API ವೆಚ್ಚಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ: ಅನೇಕ API ಕರೆಗಳು ಉಚಿತವಾಗಿದ್ದರೂ, ಕೆಲವು ವೆಚ್ಚಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು, ವಿಶೇಷವಾಗಿ ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ `List` ಅಥವಾ `Get` ವಿನಂತಿಗಳು. ನೀವು ಬಳಸುವ ಸೇವೆಗಳಿಗೆ AWS ಬೆಲೆ ಮಾದರಿಯ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ.
- ರಿಸೋರ್ಸ್‌ಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ: ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ರಚಿಸಲಾದ ರಿಸೋರ್ಸ್‌ಗಳನ್ನು ಯಾವಾಗಲೂ ಟರ್ಮಿನೇಟ್ ಮಾಡಿ ಅಥವಾ ಅಳಿಸಿ. ಮೇಲಿನ EC2 ಮತ್ತು S3 ಉದಾಹರಣೆಗಳು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿವೆ. ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು Boto3 ಗಾಗಿಯೇ ಒಂದು ಉತ್ತಮ ಬಳಕೆಯಾಗಿದೆ!
ತೀರ್ಮಾನ: ಕ್ಲೌಡ್ ಮಾಸ್ಟರಿಗೆ ನಿಮ್ಮ ಪ್ರಯಾಣ
Boto3 ಕೇವಲ ಒಂದು ಲೈಬ್ರರಿಗಿಂತ ಹೆಚ್ಚು; ಇದು ಸಂಪೂರ್ಣ AWS ಪರಿಸರ ವ್ಯವಸ್ಥೆಯ ಮೇಲೆ ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ನಿಯಂತ್ರಣಕ್ಕೆ ಒಂದು ಗೇಟ್‌ವೇ ಆಗಿದೆ. ಅದರ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳಾದ - ಕ್ಲೈಂಟ್‌ಗಳು ಮತ್ತು ರಿಸೋರ್ಸ್‌ಗಳು, ದೋಷ ನಿಭಾಯಿಸುವಿಕೆ, ವೇಟರ್ಸ್, ಮತ್ತು ಪೇಜಿನೇಟರ್ಸ್ - ಮೇಲೆ ಪ್ರಾವೀಣ್ಯತೆ ಹೊಂದುವ ಮೂಲಕ, ನೀವು ಮೂಲಸೌಕರ್ಯವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ, ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುವ ಮತ್ತು ಭದ್ರತೆಯನ್ನು ಪ್ರಮಾಣದಲ್ಲಿ ಜಾರಿಗೊಳಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡುತ್ತೀರಿ.
ಪ್ರಯಾಣ ಇಲ್ಲಿಗೆ ಮುಗಿಯುವುದಿಲ್ಲ. ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ತತ್ವಗಳು ಮತ್ತು ಮಾದರಿಗಳು Boto3 ನಿಂದ ಬೆಂಬಲಿತವಾದ ನೂರಾರು ಇತರ AWS ಸೇವೆಗಳಿಗೆ ಅನ್ವಯಿಸುತ್ತವೆ, RDS ನೊಂದಿಗೆ ಡೇಟಾಬೇಸ್ ನಿರ್ವಹಣೆಯಿಂದ ಹಿಡಿದು SageMaker ನೊಂದಿಗೆ ಮಷೀನ್ ಲರ್ನಿಂಗ್‌ವರೆಗೆ. ಅಧಿಕೃತ Boto3 ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಪ್ರತಿ ಸೇವೆಗೆ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಒಂದು ಅತ್ಯುತ್ತಮ ಸಂಪನ್ಮೂಲವಾಗಿದೆ.
Boto3 ಅನ್ನು ನಿಮ್ಮ ವರ್ಕ್‌ಫ್ಲೋಗೆ ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ನೀವು ಕೋಡ್ ಆಗಿ ಮೂಲಸೌಕರ್ಯದ ಅಭ್ಯಾಸವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುತ್ತಿದ್ದೀರಿ ಮತ್ತು ವಿಶ್ವದ ಪ್ರಮುಖ ಕ್ಲೌಡ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಹೆಚ್ಚು ದೃಢವಾದ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ಸಮರ್ಥ ಪರಿಹಾರಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೂ ಮತ್ತು ನಿಮ್ಮ ತಂಡಕ್ಕೂ ಅಧಿಕಾರ ನೀಡುತ್ತಿದ್ದೀರಿ. ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್!