ദൈനംദിന ഓട്ടോമേഷന് വേണ്ടി പൈഥണ്

ഒരു ബാഷ് സ്ക്രിപ്റ്റ് നൂറ് വരികൾക്കപ്പുറം വളരുമ്പോള് , അല്ലെങ്കിൽ ഒരു API- യുമായി സംസാരിക്കാന് ആവശ്യപ്പെടുമ്പോള്, ഞാന് പൈഥോണിലേക്ക് മാറുന്നു. വായിക്കാവുന്നതാണ്, മിക്കവാറും എല്ലാത്തിനും ഒരു ലൈബ്രറിയുണ്ട്, സഹപ്രവർത്തകര് ക്ക് ഡീകോഡിംഗ് സെഷന് ഇല്ലാതെ തന്നെ അത് മനസ്സിലാക്കാൻ കഴിയും.

DevOps-നു വേണ്ടി ഉപയോഗപ്രദമായ പൈത്തൺ എഴുതാൻ സോഫ്റ്റ് വെയർ എഞ്ചിനീയർ ആവേണ്ട ആവശ്യമില്ല. കുറച്ച് ലൈബ്രറികളും ശീലങ്ങളും നിങ്ങൾക്ക് ആവശ്യമുള്ള മിക്കതും ഉൾക്കൊള്ളുന്നു.

ഞാന് ഉപയോഗിക്കുന്ന ലൈബ്രറികള്

• ബോട്ടോ3: ആ ഡബ്ല്യു എസ് എസ് എസ് കെ. AWS ലെ എല്ലാ കാര്യങ്ങളും ഇതില് നിന്നും ലഭ്യമാണ്. (അസ്യൂറിന് azure-identity സേവന SDK കളും ഗൂഗിൾ ക്ലൌഡും google-cloud-* ലൈബ്രറികള്)
• കുബര് നെറ്റ്സ്: ഔദ്യോഗിക കുബർനെറ്റ്സ് ക്ലയന്റ്.
• httppx അല്ലെങ്കില് അഭ്യർത്ഥനകൾ: REST API കൾ വിളിക്കുന്നു.
• തരം അല്ലെങ്കില് ക്ലിക്ക് ചെയ്യുക: ആര് ഗ്മെന്റുകളും സഹായ ടെക്സ്റ്റും ഉപയോഗിച്ച് കമാന്ഡ് ലൈന് ടൂളുകള് നിർമ്മിക്കുക.
• സമ്പന്നൻ: ടെർമിനലിലെ നല്ല പട്ടികകളും നിറങ്ങളും പുരോഗതി ബാറുകളും.
• പ്യ്ദാന്തിക്: കോൺഫിഗറേഷനും ഡാറ്റയും പരിശോധിക്കുന്നു.
• പ്യ്യാംല് / റൂമൽ.: YAML വായിക്കുകയും എഴുതുകയും ചെയ്യുക.
• കഠിനാധ്വാനം: പി. എ. ഐ. കളുടെ അഭാവം പരിശോധിക്കുന്നു.

UV ഉള്ള പാക്കേജിംഗ്

പൈത്തൺ പാക്കേജിംഗ് വേദനയേറിയതായിരുന്നു: വിർച്വൽ പരിതസ്ഥിതികൾ, പിപ്, ആവശ്യകത ഫയലുകൾ, പതിപ്പ് വൈരുദ്ധ്യങ്ങൾ. uv, ആസ്ട്രലില് നിന്നും, അത് വളരെ ലളിതവും വേഗവുമാക്കി.

uv init cloud-tools
cd cloud-tools
uv add boto3 typer rich
uv run python main.py

ചെറിയ സ്ക്രിപ്റ്റുകളിലെ എന്റെ പ്രിയപ്പെട്ട സവിശേഷത: ഇൻലൈൻ ആശ്രിതത്വം. ഒരു ഫയലിന്റെ മുകളില് നിങ്ങള്ക്ക് ആശ്രയത്വങ്ങള് പ്രഖ്യാപിക്കാം, uv run പരിസ്ഥിതി യാന്ത്രികമായി കൈകാര്യം ചെയ്യുന്നു:

# /// script
# requires-python = ">=3.12"
# dependencies = ["boto3", "typer", "rich"]
# ///

പിന്നെ ആർക്കും ഓടാം. uv run cleanup.py ഒന്നും ക്രമീകരിക്കാതെ. ഒരു ടീമിൽ ചെറിയ ഉപകരണങ്ങൾ പങ്കുവയ്ക്കാൻ പറ്റിയതാണ്.

ഏറ്റവും നല്ല ഓട്ടോമേഷൻ സ്ക്രിപ്റ്റ് നാളെ ഒരു സഹപ്രവർത്തകന് എങ്ങനെ ചെയ്യണമെന്ന് ചോദിക്കാതെ തന്നെ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നതാണ്.

ഉദാഹരണംഃ ഉപയോഗിക്കാത്ത ക്ലൌഡ് റിസോഴ്സുകൾ കണ്ടെത്തുക

ഒരു യഥാർത്ഥ ലോക ഉദാഹരണംഃ ബന്ധിപ്പിക്കാത്ത EBS വോള്യങ്ങൾ കണ്ടെത്തുക (ഒരു ക്ലാസിക് മാലിന്യ സ്രോതസ്സ്) അവയെ ഇല്ലാതാക്കുക.

# /// script
# requires-python = ">=3.12"
# dependencies = ["boto3", "typer", "rich"]
# ///
import boto3
import typer
from rich.console import Console
from rich.table import Table

app = typer.Typer()
console = Console()


@app.command()
def unattached_volumes(
    region: str = "eu-central-1",
    delete: bool = typer.Option(False, help="Actually delete the volumes"),
):
    """List (and optionally delete) unattached EBS volumes."""
    ec2 = boto3.client("ec2", region_name=region)
    paginator = ec2.get_paginator("describe_volumes")
    pages = paginator.paginate(Filters=[{"Name": "status", "Values": ["available"]}])

    table = Table("Volume ID", "Size (GiB)", "Created", "Name")
    volumes = []
    for page in pages:
        for v in page["Volumes"]:
            name = next((t["Value"] for t in v.get("Tags", []) if t["Key"] == "Name"), "-")
            table.add_row(v["VolumeId"], str(v["Size"]), v["CreateTime"].date().isoformat(), name)
            volumes.append(v["VolumeId"])

    console.print(table)
    console.print(f"[bold]{len(volumes)}[/bold] unattached volumes in {region}")

    if delete and volumes and typer.confirm("Delete all of them?"):
        for vol_id in volumes:
            ec2.delete_volume(VolumeId=vol_id)
            console.print(f"Deleted {vol_id}")


if __name__ == "__main__":
    app()

ചില ശീലങ്ങൾ ശ്രദ്ധിക്കുക:

• പേജിനേഷൻ: AWS API കൾ പേജുകളിലെ ഫലങ്ങൾ തിരികെ നൽകുന്നു. എപ്പോഴും പേജിനേറ്റർ ഉപയോഗിക്കുക, അല്ലെങ്കിൽ ആദ്യത്തെ പേജ് മാത്രമേ കാണൂ.
• സ്ഥിരമായി ഡ്രൈ റൺ: അത് ലിസ്റ്റുചെയ്യുന്നു, നിങ്ങൾ പാസാകാത്ത പക്ഷം മാത്രം. --delete, പിന്നെ സ്ഥിരീകരണം ആവശ്യപ്പെടുകയും ചെയ്യുന്നു.
• വായിക്കാവുന്ന ഔട്ട്പുട്ട് ഒരു മേശയും.

ഉദാഹരണം: ഒരു കുബർനെറ്റസ് റിപ്പോർട്ട്

ഏത് പാഡുകളിലാണ് വിഭവ അഭ്യർത്ഥനകളില്ലാത്തത്? ഒരു ചോദ്യം പലപ്പോഴും ഉയരുന്നുണ്ട്:

from kubernetes import client, config

config.load_kube_config()  # or load_incluster_config() inside a pod
v1 = client.CoreV1Api()

for pod in v1.list_pod_for_all_namespaces().items:
    for c in pod.spec.containers:
        requests = (c.resources and c.resources.requests) or {}
        if "cpu" not in requests or "memory" not in requests:
            print(f"{pod.metadata.namespace}/{pod.metadata.name} [{c.name}] missing requests")

പത്ത് വരികൾ, പിന്നെ നിനക്ക് ഒരു റിപ്പോർട്ട് കിട്ടും, അത് എല്ലാ ആഴ്ചയും ഐ. സി. യിൽ പോസ്റ്റ് ചെയ്യാം.

ഓട്ടോമേഷൻ സ്ക്രിപ്റ്റുകളുടെ ശീലങ്ങൾ

• സ്ഥിരമായി ഡ്രൈ റൺ നശിപ്പിക്കുന്ന ഏതൊരു കാര്യത്തിനും വേണ്ടി.
• സാധാരണ ക്രെഡൻഷ്യൽ ചെയിൻ ഉപയോഗിക്കുക (പരിസ്ഥിതി, പ്രൊഫൈലുകൾ, എസ്എസ്ഒ, ഇൻസ്റ്റൻസി റോളുകൾ) ഒരിക്കലും ഹാർഡ് കോഡ് ക്രെഡൻഷ്യലുകൾ.
• നിങ്ങള് ചെയ്യുന്നതെല്ലാം രേഖപ്പെടുത്തുക, പിന്നീട് പുനർനിർമിക്കാൻ മതിയായ വിശദാംശങ്ങളോടെ.
• പിശകുകളും വീണ്ടും ശ്രമങ്ങളും കൈകാര്യം ചെയ്യുക നെറ്റ് വർക്ക് കോളുകള് ക്ക് വേണ്ടി.
• തരം സൂചനകൾ ചേർക്കുക ഒരു ലിന്ററും ഫോർമാറ്ററും പ്രവർത്തിപ്പിക്കുക.
• ഒരു ചെറിയ ടെസ്റ്റ് എഴുതൂ. പ്രധാനപ്പെട്ട യുക്തിക്ക് വേണ്ടി.
• ഗിറ്റിലേയ്ക്ക് മാറ്റുക, ഒരു README ഉപയോഗിച്ച് അത് എന്താണ് ചെയ്യുന്നതെന്നും അത് എങ്ങനെ പ്രവർത്തിപ്പിക്കാമെന്നും വിശദീകരിക്കുന്നു.

സ്ക്രിപ്റ്റിൽ നിന്നും ടൂളിലേക്ക്

ഒരു തിരക്കഥ ടീം ആശ്രയിക്കുന്ന ഒന്നായി മാറുമ്പോൾ:

• ടൈപ്പറിനും സഹായ ടെക്സ്റ്റിനും ഒരു ശരിയായ CLI നൽകുക.
• ഇത് UV കൊണ്ട് പാക്കേജ് ചെയ്യുക, അങ്ങനെ അത് uv tool install.
• ഐ. ഐ. യിലോ ലാപ്ടോപ്പുകളിലോ അല്ലാതെ ഒരു കുബർനെറ്റ്സ് ക്രോൺജോബിലോ പ്രവർത്തിപ്പിക്കുക.
• നിങ്ങളുടെ പ്ലാറ്റ്ഫോമിന്റെ ഭാഗമാകണോ അതോ ഓപ്പറേറ്ററാകണോ എന്ന് ആലോചിക്കുക.

എവിടെ നിന്നാണ് ഞാൻ തുടങ്ങേണ്ടത്?

ഓരോ ആഴ്ചയും നിങ്ങൾ ചെയ്യുന്ന ഒരു ആവർത്തിച്ചുള്ള ജോലി തിരഞ്ഞെടുക്കുക, ഉദാഹരണത്തിന് വിഭവങ്ങൾ വൃത്തിയാക്കുക, ഒരു റിപ്പോർട്ട് സൃഷ്ടിക്കുക അല്ലെങ്കിൽ സർട്ടിഫിക്കറ്റുകൾ പരിശോധിക്കുക. യുവി യുടെ ഇൻലൈൻ ആശ്രിതത്വങ്ങളുള്ള ഒരു ചെറിയ പൈഥൺ സ്ക്രിപ്റ്റ് എഴുതുക. അത് പങ്കുവെക്കൂ. ടീം എത്ര പെട്ടെന്ന് കൂടുതൽ ആവശ്യപ്പെടുന്നു എന്ന് നിങ്ങള് ക്ക് അത്ഭുതപ്പെടും.

എന്റെ അഭിപ്രായം: പൈത്തൺ "ഞാൻ ഇത് കൈകൊണ്ട് ചെയ്യും, ഇത് പത്ത് മിനിറ്റ് മാത്രമേ എടുക്കൂ" എന്ന് "ഇത് എല്ലാ രാത്രിയും പ്രവർത്തിക്കുന്നു, ആരും അതിനെക്കുറിച്ച് ചിന്തിക്കുന്നില്ല" എന്ന് മാറ്റുന്നു.

ഡെസ്ലി