Suchen und Validieren ungenutzter Sicherheitsgruppen in AWS mit Python und Boto3

Die effektive Verwaltung von AWS-Sicherheitsgruppen ist entscheidend für die Aufrechterhaltung einer sicheren und kosteneffizienten Cloud-Umgebung. Sicherheitsgruppen sind ein wichtiger Bestandteil der Netzwerksicherheit in AWS, aber mit der Zeit können sich ungenutzte Sicherheitsgruppen ansammeln. Diese ungenutzten Gruppen überladen nicht nur Ihre Umgebung, sondern können auch Sicherheitsrisiken darstellen oder die Kosten unnötig erhöhen.

In diesem Artikel erfahren Sie, wie Sie mit Python und Boto3 ungenutzte Sicherheitsgruppen in Ihrer AWS-Umgebung identifizieren, validieren und sicherstellen, dass sie nicht von anderen Ressourcen referenziert werden. Wir werden uns auch damit befassen, wie Sie sicher feststellen können, ob diese Gruppen gelöscht werden können.

Voraussetzungen

Um diesem Tutorial folgen zu können, benötigen Sie Folgendes:

Ein AWS-Konto: Stellen Sie sicher, dass Sie Zugriff auf die AWS-Umgebung haben, in der Sie nach nicht verwendeten Sicherheitsgruppen suchen möchten.
Boto3 installiert: Sie können das Boto3 Python SDK installieren, indem Sie Folgendes ausführen:

   pip install boto3

AWS-Anmeldeinformationen konfiguriert: Stellen Sie sicher, dass Sie AWS-Anmeldeinformationen entweder über die AWS CLI oder direkt in Ihrem Code mithilfe von IAM-Rollen oder Umgebungsvariablen konfiguriert haben.

Code-Aufschlüsselung

Lassen Sie uns den Code durchgehen, der nicht verwendete Sicherheitsgruppen in einer bestimmten AWS-Region identifiziert, sie validiert und prüft, ob sie von anderen Gruppen referenziert werden.

Schritt 1: Holen Sie sich alle Sicherheitsgruppen und ENIs

   pip install boto3

• Sicherheitsgruppen abrufen: Wir rufen zunächst die Methode „describe_security_groups“ auf, um alle Sicherheitsgruppen in der angegebenen Region abzurufen.
• Netzwerkschnittstellen abrufen: Als Nächstes rufen wir alle Netzwerkschnittstellen mit „describe_network_interfaces“ ab. Jeder Netzwerkschnittstelle können eine oder mehrere Sicherheitsgruppen zugeordnet sein.
• Identifizieren verwendeter Sicherheitsgruppen: Für jede Netzwerkschnittstelle fügen wir die zugehörigen Sicherheitsgruppen-IDs zu einem Satz namens used_sg_ids hinzu.
• Unbenutzte Gruppen finden: Anschließend vergleichen wir die Sicherheitsgruppen-IDs mit den verwendeten. Wenn eine Gruppe nicht verwendet wird (d. h. ihre ID ist nicht im used_sg_ids-Satz enthalten), betrachten wir sie als ungenutzt, mit Ausnahme der Standardsicherheitsgruppe, die nicht gelöscht werden kann.

Schritt 2: Überprüfen Sie die Sicherheitsgruppenreferenzen

import boto3
from botocore.exceptions import ClientError

def get_unused_security_groups(region='us-east-1'):
    """
    Find security groups that are not being used by any resources.
    """
    ec2_client = boto3.client('ec2', region_name=region)

    try:
        # Get all security groups
        security_groups = ec2_client.describe_security_groups()['SecurityGroups']

        # Get all network interfaces
        enis = ec2_client.describe_network_interfaces()['NetworkInterfaces']

        # Create set of security groups in use
        used_sg_ids = set()

        # Check security groups attached to ENIs
        for eni in enis:
            for group in eni['Groups']:
                used_sg_ids.add(group['GroupId'])

        # Find unused security groups
        unused_groups = []
        for sg in security_groups:
            if sg['GroupId'] not in used_sg_ids:
                # Skip default security groups as they cannot be deleted
                if sg['GroupName'] != 'default':
                    unused_groups.append({
                        'GroupId': sg['GroupId'],
                        'GroupName': sg['GroupName'],
                        'Description': sg['Description'],
                        'VpcId': sg.get('VpcId', 'EC2-Classic')
                    })

        # Print results
        if unused_groups:
            print(f"\nFound {len(unused_groups)} unused security groups in {region}:")
            print("-" * 80)
            for group in unused_groups:
                print(f"Security Group ID: {group['GroupId']}")
                print(f"Name: {group['GroupName']}")
                print(f"Description: {group['Description']}")
                print(f"VPC ID: {group['VpcId']}")
                print("-" * 80)
        else:
            print(f"\nNo unused security groups found in {region}")

        return unused_groups

    except ClientError as e:
        print(f"Error retrieving security groups: {str(e)}")
        return None

• Auf Referenzen prüfen: Diese Funktion prüft, ob eine bestimmte Sicherheitsgruppe von anderen Sicherheitsgruppen referenziert wird. Dies geschieht durch das Filtern von Sicherheitsgruppen basierend auf ihren eingehenden (ip-permission.group-id) und ausgehenden (egress.ip-permission.group-id) Regeln.
• Referenzierende Gruppen zurückgeben: Wenn auf die Gruppe verwiesen wird, gibt die Funktion eine Liste der verweisenden Sicherheitsgruppen zurück. Wenn nicht, wird None zurückgegeben.

Schritt 3: Validieren Sie nicht verwendete Sicherheitsgruppen

def check_sg_references(ec2_client, group_id):
    """
    Check if a security group is referenced in other security groups' rules
    """
    try:
        # Check if the security group is referenced in other groups
        response = ec2_client.describe_security_groups(
            Filters=[
                {
                    'Name': 'ip-permission.group-id',
                    'Values': [group_id]
                }
            ]
        )

        referencing_groups = response['SecurityGroups']

        # Check for egress rules
        response = ec2_client.describe_security_groups(
            Filters=[
                {
                    'Name': 'egress.ip-permission.group-id',
                    'Values': [group_id]
                }
            ]
        )

        referencing_groups.extend(response['SecurityGroups'])

        return referencing_groups

    except ClientError as e:
        print(f"Error checking security group references: {str(e)}")
        return None

• Validieren nicht verwendeter Sicherheitsgruppen: In diesem letzten Schritt ruft das Skript zunächst die nicht verwendeten Sicherheitsgruppen ab. Anschließend wird für jede nicht verwendete Gruppe geprüft, ob eine andere Sicherheitsgruppe in ihren Regeln darauf verweist.
• Ausgabe: Das Skript gibt aus, ob auf die Gruppe verwiesen wird oder nicht, und wenn nicht, kann sie sicher gelöscht werden.

Ausführen des Skripts

Um das Skript auszuführen, führen Sie einfach die Funktion „validate_unused_groups“ aus. Wenn die Region beispielsweise auf us-east-1 eingestellt ist, wird das Skript Folgendes tun:

1. Alle Sicherheitsgruppen und Netzwerkschnittstellen in us-east-1 abrufen.
2. Identifizieren Sie nicht verwendete Sicherheitsgruppen.
3. Überprüfen und melden Sie, ob auf diese nicht verwendeten Gruppen von anderen Sicherheitsgruppen verwiesen wird.

Beispielausgabe

def validate_unused_groups(region='us-east-1'):
    """
    Validate and provide detailed information about unused security groups
    """
    ec2_client = boto3.client('ec2', region_name=region)
    unused_groups = get_unused_security_groups(region)

    if not unused_groups:
        return

    print("\nValidating security group references...")
    print("-" * 80)

    for group in unused_groups:
        group_id = group['GroupId']
        referencing_groups = check_sg_references(ec2_client, group_id)

        if referencing_groups:
            print(f"\nSecurity Group {group_id} ({group['GroupName']}) is referenced by:")
            for ref_group in referencing_groups:
                print(f"- {ref_group['GroupId']} ({ref_group['GroupName']})")
        else:
            print(f"\nSecurity Group {group_id} ({group['GroupName']}) is not referenced by any other groups")
            print("This security group can be safely deleted if not needed")

Abschluss

Mit diesem Skript können Sie den Prozess der Suche nach ungenutzten Sicherheitsgruppen in AWS automatisieren und sicherstellen, dass Sie keine unnötigen Ressourcen behalten. Dies kann dazu beitragen, Unordnung zu vermeiden, die Sicherheitslage zu verbessern und möglicherweise die Kosten zu senken, indem ungenutzte Ressourcen entfernt werden.

Sie können dieses Skript erweitern auf:

• Erledigen Sie zusätzliche Filterung basierend auf Tags, VPCs oder anderen Kriterien.
• Implementieren Sie erweiterte Berichte oder Benachrichtigungen, wenn ungenutzte Gruppen erkannt werden.
• Integration mit AWS Lambda für automatisierte, geplante Prüfungen.

Halten Sie Ihre AWS-Umgebung sicher und gut organisiert!

Das obige ist der detaillierte Inhalt vonSuchen und Validieren ungenutzter Sicherheitsgruppen in AWS mit Python und Boto3. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!