Zum Hauptinhalt springen
Übersetzte Seite

Diese Seite wurde mit KI-Unterstützung aus dem Englischen übersetzt. Bei Abweichungen ist die englische Version maßgeblich.

Globales AWS-Inventar

In dieser Anleitung zeigen wir, wie Sie mit StackQL - einem leistungsfähigen Entwicklungstool, mit dem sich Cloud-Infrastruktur und -Ressourcen per SQL-Syntax abfragen und bereitstellen lassen - ein umfassendes Inventar aller Ressourcen in allen Services in allen Regionen eines AWS-Kontos erstellen.

Getestet mit eingebettetes SQL-Backend Postgres-SQL-Backend macos linux powershell

Funktionsweise​

StackQL implementiert eine SQL-Engine, die mehrere Abfragen asynchron verarbeiten kann, zum Beispiel:

SELECT region, COUNT(*) as num_functions
FROM aws.lambda.functions
WHERE region IN (
	'us-east-1','us-east-2','us-west-1','us-west-2',
	'ap-south-1','ap-northeast-3','ap-northeast-2',
	'ap-southeast-1','ap-southeast-2','ap-northeast-1',
	'ca-central-1','eu-central-1','eu-west-1',
	'eu-west-2','eu-west-3','eu-north-1','sa-east-1')
GROUP BY region;

Die obige Abfrage besteht tatsächlich aus 17 parallel ausgeführten Abfragen (eine Abfrage pro Region); die Ergebnisse werden aggregiert und als Bericht dargestellt. Mit pystackql - einem Python-Wrapper für StackQL - können wir alle Ressourcen in allen Services für alle Regionen durchlaufen, die vom jeweiligen Service unterstützt werden. Das Ergebnis ist ein Bericht darüber, wie viele Instanzen jeder Ressource in jeder Region bereitgestellt sind, wie im folgenden Beispiel zu sehen:

Beispiel für ein AWS-Inventar

Voraussetzungen​

  • pystackql, installierbar mit pip install pystackql
  • Ein AWS-Benutzer oder eine Rolle (kann mit sts assume-role angenommen werden) mit zugewiesener Richtlinie ReadOnlyAccess oder weitergehenden Berechtigungen
  • Gesetzte Umgebungsvariablen AWS_ACCESS_KEY_ID und AWS_SECRET_ACCESS_KEY (dies kann automatisch über AWS Cloud Shell erfolgen)

Der Code​

Der folgende Code führt die folgenden Aktionen aus:

  1. Definiert eine Liste aller AWS-Regionen (regions) und eine Liste der von jedem Service unterstützten Regionen (supported_regions); weitere Informationen zur Ableitung von supported_regions finden Sie unter AWS Service Support by Region at a Glance
  2. Lädt die StackQL-Provider aws und aws herunter, falls sie noch nicht installiert sind.
  3. Durchläuft jeden Service (mit SHOW SERVICES) und anschließend für jeden Service jede Ressource (mit SHOW RESOURCES)
  4. Wählt mit SELECT alle Instanzen jeder Ressource über alle Regionen hinweg asynchron aus, gruppiert die Daten nach Region und zählt die Instanzen jeder Ressource für jede Region

Hier ist er...

from regions import supported_regions, regions
from resources import excluded_resources, resource_filters
import time
from pystackql import StackQL
import pandas as pd

stackql = StackQL(output='pandas', page_limit=-1, execution_concurrency_limit=-1)

def pull_stackql_providers():
    providers_df = stackql.execute("SHOW PROVIDERS")
    installed = providers_df['name'].values if not providers_df.empty else []
    for provider in ('aws', 'awscc'):
        if provider not in installed:
            print(f"{provider} not installed. Installing {provider}")
            res = stackql.executeStmt(f"REGISTRY PULL {provider}")
            print(res['message'])

def get_s3_buckets():
    # special case for s3 buckets - use the awscc provider's list view, which
    # returns each bucket alongside its region in a single query across all regions
    regions_in = ", ".join([f"'{region}'" for region in regions])
    buckets_df = stackql.execute(f"""
        SELECT region, bucket_name
        FROM awscc.s3.buckets_list_only
        WHERE region IN ({regions_in});
    """)
    # Group by region and count the total resources (buckets) in each region
    grouped = buckets_df.groupby('region').size().reset_index(name='total_resources')
    grouped['svc'] = 's3'
    grouped['res'] = 'buckets'
    output_df = grouped[['svc', 'res', 'region', 'total_resources']]
    return output_df

def main():
    start_time = time.time()
    pull_stackql_providers()    
    results_df = pd.DataFrame(columns=['svc', 'res', 'region', 'total_resources'])
    # get all enumerable aws services
    services_df = stackql.execute("SHOW SERVICES IN aws")
    for svcIx, svcRow in services_df.iterrows():
        service = svcRow['name']
        if service in supported_regions:
            # check all enumerable aws resources in the service against supported regions
            resources_df = stackql.execute(f"SHOW RESOURCES IN aws.{service}")
            plural_resources = [resource for resource in resources_df['name'].tolist() if resource.endswith('s')]
            if plural_resources:
                for resource in plural_resources:
                    print(f"Checking {resource} in {service}...")
                    if service == 's3' and resource == 'buckets':
                        print(f"Checking location for s3 buckets...")
                        resource_df = get_s3_buckets()
                    else:
                        # should we skip this service?
                        if service in excluded_resources and resource in excluded_resources[service]:
                            continue
                        # check if the resource is global or regional
                        if 'global' in supported_regions[service]:
                            regions_in = ", ".join([f"'{region}'" for region in regions])
                        else:
                            regions_in = ", ".join([f"'{region}'" for region in supported_regions[service]])      
                        
                        # check if there are additional where clauses for this resource
                        where_clause = resource_filters.get(service, {}).get(resource, '')
                        
                        resource_df = stackql.execute(f"""
                            SELECT '{service}' as svc, '{resource}' as res, region, COUNT(*) as total_resources  
                            FROM aws.{service}.{resource} 
                            WHERE region IN ({regions_in}){where_clause}
                            GROUP BY svc, res, region
                        """)

                    if not resource_df.empty:
                        # Append resource_df to the results_df
                        if not 'error' in resource_df.columns:
                            results_df = pd.concat([results_df, resource_df], ignore_index=True)
    end_time = time.time()
    elapsed_time = end_time - start_time
    print(f"Elapsed time: {elapsed_time:.2f} seconds")
    results_df.to_csv('all_aws_resources.csv', index=False)

if __name__ == "__main__":
    main()