AWS-ஐ பைத்தான் மூலம் கையாளுதல்: கிளவுட் சேவை ஒருங்கிணைப்பிற்கான Boto3 SDK-ஐ ஆழமாகப் புரிந்துகொள்ளுதல்

கிளவுட் கம்ப்யூட்டிங் உலகில், Amazon Web Services (AWS) ஒரு உலகளாவிய தலைவராக நிற்கிறது, இது பரந்த மற்றும் எப்போதும் விரிவடைந்து வரும் சேவைகளின் தொகுப்பை வழங்குகிறது. டெவலப்பர்கள், DevOps பொறியாளர்கள் மற்றும் சிஸ்டம் ஆர்க்கிடெக்டுகளுக்கு, இந்தச் சேவைகளுடன் நிரலாக்க ரீதியாக தொடர்புகொள்வது ஒரு வசதி மட்டுமல்ல — இது ஒரு அவசியமாகும். அளவிடக்கூடிய, நெகிழ்திறன் கொண்ட மற்றும் திறமையான கிளவுட் உள்கட்டமைப்பை நிர்வகிப்பதற்கான திறவுகோல் ஆட்டோமேஷன் ஆகும். இங்கேயுள்ள Boto3, பைத்தானுக்கான அதிகாரப்பூர்வ AWS SDK, உங்கள் ஆயுதக் களஞ்சியத்தில் ஒரு அத்தியாவசிய கருவியாகிறது.

இந்த விரிவான வழிகாட்டி உலகளாவிய பார்வையாளர்களுக்காக வடிவமைக்கப்பட்டுள்ளது, Boto3-ஐ ஆழமாகப் புரிந்துகொள்ள உதவுகிறது. அடிப்படைகளுடன் தொடங்கி, முக்கிய AWS சேவைகளுடன் நடைமுறை எடுத்துக்காட்டுகளைப் பார்ப்போம், மேலும் மேம்பட்ட கருத்துகள் மற்றும் சிறந்த நடைமுறைகளை ஆராய்வோம். நீங்கள் ஒரு எளிய பணியை தானியக்கமாக்கினாலும் அல்லது ஒரு சிக்கலான, கிளவுட்-நேட்டிவ் பயன்பாட்டை உருவாக்கினாலும், Boto3-ஐ மாஸ்டரிங் செய்வது AWS-இன் முழு திறனையும் பயன்படுத்த உங்களுக்கு அதிகாரம் அளிக்கும்.

Boto3 உடன் தொடங்குதல்: AWS ஆட்டோமேஷனில் உங்கள் முதல் படிகள்

எந்த குறியீட்டையும் எழுதுவதற்கு முன், நாம் ஒரு பாதுகாப்பான மற்றும் செயல்பாட்டு வளர்ச்சி சூழலை அமைக்க வேண்டும். AWS உடன் உங்கள் தொடர்புகள் வெற்றிகரமானதாகவும் பாதுகாப்பானதாகவும் இருப்பதை உறுதி செய்ய இந்த ஆரம்ப அமைவு மிகவும் முக்கியமானது.

உலகளாவிய வளர்ச்சி சூழலுக்கான முன்நிபந்தனைகள்

• பைத்தான் நிறுவல்: Boto3 ஒரு பைத்தான் நூலகம், எனவே உங்களுக்கு பைத்தான் நிறுவப்பட்டிருக்க வேண்டும். இது பல்வேறு பைத்தான் பதிப்புகளை ஆதரிக்கிறது. பைத்தான் 3-இன் சமீபத்திய நிலையான பதிப்பைப் பயன்படுத்த நாங்கள் பரிந்துரைக்கிறோம். பைத்தானின் குறுக்கு-தள இயல்பு, உலகெங்கிலும் பரவியுள்ள அணிகளுக்கு ஒரு சிறந்த தேர்வாக அமைகிறது.
• ஒரு AWS கணக்கு: உங்களிடம் ஏற்கனவே ஒரு 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 அணுகல் முக்கிய ஐடி: உங்கள் தனித்துவமான அடையாளங்காட்டி.
• AWS ரகசிய அணுகல் முக்கியம்: உங்கள் ரகசிய கடவுச்சொல். இதை எந்த கடவுச்சொல் போலவும் கையாளவும்.
• இயல்புநிலை மண்டலப் பெயர்: உங்கள் குறியீடு இயல்பாக இணைக்கப்படும் AWS மண்டலம் (எ.கா., `us-west-2`).
• இயல்புநிலை வெளியீட்டு வடிவம்: பொதுவாக `json`.

இந்த கட்டளை உங்கள் சான்றுகளை `~/.aws/credentials` இல் உள்ள கோப்புகளிலும், உங்கள் இயல்புநிலை மண்டலம்/வெளியீட்டு வடிவமைப்பை `~/.aws/config` இல் உள்ள கோப்புகளிலும் பாதுகாப்பாக சேமிக்கிறது. Boto3 தானாகவே இந்தக் கோப்புகளைத் தேடத் தெரியும், எனவே உங்கள் ஸ்கிரிப்டுகளில் சான்றுகளைக் குறிப்பிடத் தேவையில்லை. இந்த முறை உங்கள் குறியீட்டை போர்ட்டபிள் மற்றும் பாதுகாப்பானதாக ஆக்குகிறது, ஏனெனில் முக்கியமான விசைகள் உங்கள் பயன்பாட்டுத் தர்க்கத்திலிருந்து தனித்தனியாக வைக்கப்படுகின்றன.

Boto3 இன் முக்கிய கூறுகள்: கிளையண்டுகள் மற்றும் ஆதாரங்கள்

Boto3, கிளையண்டுகள் மற்றும் ஆதாரங்கள் என அறியப்படும் AWS சேவைகளுடன் தொடர்பு கொள்ள இரண்டு தனித்துவமான வழிகளை வழங்குகிறது. இந்த வித்தியாசத்தைப் புரிந்துகொள்வது பயனுள்ள மற்றும் படிக்கக்கூடிய குறியீட்டை எழுதுவதற்கு முக்கியமாகும்.

இரண்டு சுருக்கங்களைப் புரிந்துகொள்ளுதல்

அவற்றை இரண்டு வெவ்வேறு தொடர்பு நிலைகளாகக் கருதுங்கள்:

• கிளையண்டுகள் (குறைந்த-நிலை): அடிப்படையான AWS சேவை API செயல்பாடுகளுக்கு நேரடி, ஒன்றுக்கு ஒன்று மேப்பிங்கை வழங்குகின்றன. ஒரு சேவையில் சாத்தியமான ஒவ்வொரு செயலும் அதன் கிளையன்ட் மூலம் கிடைக்கும். பதில்கள் பொதுவாக அகராதிகள், API இலிருந்து வரும் மூல JSON பதிலைப் போலவே இருக்கும்.
• ஆதாரங்கள் (உயர்-நிலை): மிகவும் சுருக்கமான, பொருள்-சார்ந்த இடைமுகத்தை வழங்குகின்றன. வெறும் முறைகளை அழைப்பதற்கு பதிலாக, பண்புக்கூறுகள் மற்றும் செயல்களைக் கொண்ட 'ஆதாரம்' பொருட்களுடன் நீங்கள் தொடர்பு கொள்கிறீர்கள். எடுத்துக்காட்டாக, நீங்கள் ஒரு பெயர் பண்புக்கூறு மற்றும் ஒரு `delete()` செயலைக் கொண்ட ஒரு `S3.Bucket` பொருளைக் கொண்டிருக்கலாம்.

கிளையன்ட் 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 சேவைகளை தானியக்கமாக்குவதன் மூலம் கோட்பாட்டை நடைமுறைக்குக் கொண்டு வருவோம்.

Amazon S3 (Simple Storage Service): உலகளாவிய தரவு மையம்

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.')

Amazon EC2 (Elastic Compute Cloud): மெய்நிகர் சேவையகங்களை நிர்வகித்தல்

EC2 மேகக்கணியில் பாதுகாப்பான, மறுஅளவிடக்கூடிய கம்ப்யூட் திறனை வழங்குகிறது. இது டெவலப்பர்களுக்கு வலை-அளவிலான கிளவுட் கம்ப்யூட்டிங்கை எளிதாக்க வடிவமைக்கப்பட்டுள்ளது.

எடுத்துக்காட்டு: ஒரு EC2 இன்ஸ்டன்ஸை தொடங்குதல் மற்றும் நிர்வகித்தல்

import boto3
import time

# EC2 ஆதாரத்தைப் பயன்படுத்தவும்
ec2 = boto3.resource('ec2', region_name='us-west-2')

# குறிப்பிட்ட மண்டலத்தில் பொருத்தமான Amazon Linux 2 AMI ஐக் கண்டறியவும்
# சமீபத்திய AMI ஐடியைப் பெற ஒரு கிளையன்டைப் பயன்படுத்துதல்
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.')

# பொது ஐபி முகவரியைப் பெற இன்ஸ்டன்ஸ் பண்புக்கூறுகளை மீண்டும் ஏற்றவும்
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 Lambda: சர்வர் இல்லாத ஒருங்கிணைப்பு

Lambda ஒரு சர்வர் இல்லாத கணக்கீட்டு சேவையாகும், இது சர்வர்களை வழங்கவோ அல்லது நிர்வகிக்கவோ தேவையில்லாமல் குறியீட்டை இயக்க உங்களை அனுமதிக்கிறது. நீங்கள் 200 க்கும் மேற்பட்ட AWS சேவைகளிலிருந்து Lambda செயல்பாடுகளைத் தூண்டலாம் அல்லது எந்த வலை அல்லது மொபைல் பயன்பாட்டிலிருந்தும் அவற்றை நேரடியாக அழைக்கலாம்.

எடுத்துக்காட்டு: ஒரு Lambda செயல்பாட்டை அழைத்தல்
முதலில், உங்கள் AWS கணக்கில் ஒரு Lambda செயல்பாடு உங்களுக்குத் தேவை. `my-data-processor` என்ற பெயரில் ஒரு எளிய செயல்பாடு உங்களிடம் இருப்பதாகக் கருதுவோம், அது ஒரு JSON பேலோடை எடுத்து, அதைச் செயல்படுத்தி, ஒரு முடிவைத் தருகிறது.

import boto3
import json

# Lambda கிளையன்டைப் பயன்படுத்தவும்
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.')

பாகினேட்டர்கள்: பெரிய தரவுத்தொகுப்புகளை திறமையாக கையாளுதல்

அதிக எண்ணிக்கையிலான பொருட்களை (ஒரு S3 பக்கெட்டில் உள்ள அனைத்து பொருட்களையும் அல்லது அனைத்து IAM பயனர்களையும் பட்டியலிடுவது போன்றவை) திருப்பித் தரக்கூடிய API அழைப்புகள் பெரும்பாலும் பாகினேட் செய்யப்படுகின்றன. இதன் பொருள் நீங்கள் ஒரு 'பக்கத்தின்' முடிவுகளையும் அடுத்த பக்கத்தைக் கோர ஒரு 'டோக்கனையும்' பெறுவீர்கள். இந்த டோக்கலை கைமுறையாக நிர்வகிப்பது சோர்வாக இருக்கலாம்.

பாகினேட்டர்கள் உங்களுக்காக டோக்கன் தர்க்கத்தைக் கையாளுவதன் மூலம் இந்த செயல்முறையை எளிதாக்குகின்றன, இது அனைத்து முடிவுகளையும் தடையின்றி மீண்டும் மீண்டும் செய்ய உங்களை அனுமதிக்கிறது.

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 மற்றும் Lambda போன்ற சேவைகளுக்கு IAM பாத்திரங்களைப் பயன்படுத்தவும், அவை தற்காலிக, தானாக சுழற்றப்படும் சான்றுகளை வழங்குகின்றன. உள்ளூர் மேம்பாட்டிற்கு, AWS CLI வழியாக கட்டமைக்கப்பட்ட `~/.aws/credentials` கோப்பைப் பயன்படுத்தவும்.
• குறைந்தபட்ச சலுகை கொள்கையைப் பயன்படுத்துங்கள்: உங்கள் ஸ்கிரிப்ட் பயன்படுத்தும் IAM பயனர் அல்லது பாத்திரம், அது செய்ய வேண்டிய செயல்களுக்கு மட்டுமே அனுமதிகளைக் கொண்டிருக்க வேண்டும். எடுத்துக்காட்டாக, ஒரு S3 பக்கெட்டில் இருந்து மட்டுமே படிக்கக்கூடிய ஒரு ஸ்கிரிப்ட் `s3:PutObject` அல்லது `s3:DeleteObject` அனுமதிகளைக் கொண்டிருக்கக்கூடாது.

செயல்திறன்

• கிளையன்ட்/ஆதாரம் பொருட்களை மீண்டும் பயன்படுத்தவும்: ஒரு Boto3 கிளையன்ட் அல்லது ஆதாரம் பொருளை உருவாக்குவது சில ஓவர்ஹெட் உள்ளது. நீண்ட நேரம் இயங்கும் பயன்பாடுகள் அல்லது Lambda செயல்பாடுகளில், பொருளை ஒருமுறை உருவாக்கி பல அழைப்புகளுக்கு மீண்டும் பயன்படுத்தவும்.
• மண்டல தாமதத்தைப் புரிந்துகொள்ளுங்கள்: முடிந்தவரை, நீங்கள் தொடர்பு கொள்ளும் சேவைகள் உள்ள அதே AWS மண்டலத்தில் உங்கள் Boto3 ஸ்கிரிப்டுகளை இயக்கவும். எடுத்துக்காட்டாக, `eu-west-1` இல் உள்ள ஒரு EC2 இன்ஸ்டன்ஸில் உங்கள் குறியீட்டை இயக்கி `eu-west-1` இல் உள்ள பிற ஆதாரங்களை நிர்வகிக்கவும். இது நெட்வொர்க் தாமதத்தை வியத்தகு முறையில் குறைக்கிறது.

குறியீடு தரம் மற்றும் பராமரிப்பு

• Boto3 அழைப்புகளை சுருக்கவும்: உங்கள் குறியீடு முழுவதும் Boto3 அழைப்புகளை சிதறவிடாதீர்கள். அவற்றை உங்கள் சொந்த செயல்பாடுகள் அல்லது வகுப்புகளில் (எ.கா., ஒரு `S3Manager` வகுப்பு) இணைக்கவும். இது உங்கள் குறியீட்டை படிக்க, சோதிக்க மற்றும் பராமரிக்க எளிதாக்குகிறது.
• பதிவு செய்தலைப் பயன்படுத்தவும்: `print()` அறிக்கைகளுக்குப் பதிலாக, பைத்தானின் `logging` தொகுதியைப் பயன்படுத்தவும். இது உங்களுக்கு verbose-ஐக் கட்டுப்படுத்தவும், வெளியீட்டை கோப்புகள் அல்லது பதிவு சேவைகளுக்கு இயக்கவும் அனுமதிக்கிறது, இது உற்பத்தி பயன்பாடுகளை பிழைத்திருத்தத்திற்கு அவசியம்.

செலவு மேலாண்மை

• API செலவுகளில் கவனமாக இருங்கள்: பல API அழைப்புகள் இலவசம் என்றாலும், சில செலவுகளை ஏற்படுத்தலாம், குறிப்பாக அதிக எண்ணிக்கையிலான `List` அல்லது `Get` கோரிக்கைகள். நீங்கள் பயன்படுத்தும் சேவைகளுக்கான AWS விலை நிர்ணய மாதிரியைப் பற்றி அறிந்திருங்கள்.
• ஆதாரங்களைச் சுத்தம் செய்யுங்கள்: மேம்பாடு மற்றும் சோதனையின் போது உருவாக்கப்பட்ட ஆதாரங்களை எப்போதும் முடிவுக்குக் கொண்டுவரவும் அல்லது நீக்கவும். மேலே உள்ள EC2 மற்றும் S3 எடுத்துக்காட்டுகள் சுத்தப்படுத்தும் படிகளை உள்ளடக்கியுள்ளன. சுத்தப்படுத்துதலை தானியக்கமாக்குவது Boto3-ஐப் பயன்படுத்துவதற்கான ஒரு சிறந்த பயன்பாட்டு வழக்கு!

முடிவுரை: கிளவுட் தேர்ச்சிக்கான உங்கள் பயணம்

Boto3 ஒரு நூலகத்தை விட அதிகம்; இது முழு AWS சுற்றுச்சூழல் அமைப்பைக் குறியீடு மூலம் கட்டுப்படுத்துவதற்கான ஒரு நுழைவாயில். அதன் முக்கிய கருத்துகளை—கிளையண்டுகள் மற்றும் ஆதாரங்கள், பிழை கையாளுதல், காத்திருப்பவர்கள் மற்றும் பாகினேட்டர்கள்—கையாளவதன் மூலம், உள்கட்டமைப்பை தானியக்கமாக்குவதற்கும், தரவை நிர்வகிப்பதற்கும், பயன்பாடுகளைப் பயன்படுத்துவதற்கும், அளவிற்கேற்ப பாதுகாப்பை அமல்படுத்துவதற்கும் திறனைத் திறக்கிறீர்கள்.

பயணம் இதனுடன் முடிவடையவில்லை. இந்த வழிகாட்டியில் விவாதிக்கப்பட்ட கொள்கைகள் மற்றும் வடிவங்கள் RDS உடன் தரவுத்தள நிர்வாகம் முதல் SageMaker உடன் இயந்திர கற்றல் வரை Boto3 ஆல் ஆதரிக்கப்படும் நூற்றுக்கணக்கான பிற AWS சேவைகளுக்கும் பொருந்தும். ஒவ்வொரு சேவைக்கும் குறிப்பிட்ட செயல்பாடுகளை ஆராய அதிகாரப்பூர்வ Boto3 ஆவணங்கள் ஒரு சிறந்த ஆதாரமாகும்.

உங்கள் பணிப்பாய்வில் Boto3 ஐ ஒருங்கிணைப்பதன் மூலம், நீங்கள் குறியீடாக உள்கட்டமைப்பு நடைமுறையைத் தழுவி, உலகின் முன்னணி கிளவுட் தளத்தில் மிகவும் உறுதியான, அளவிடக்கூடிய மற்றும் திறமையான தீர்வுகளை உருவாக்க உங்களுக்கும் உங்கள் அணிக்கும் அதிகாரம் அளிக்கிறீர்கள். மகிழ்ச்சியான குறியீட்டுடன்!