Wie identifiziere, überwache und optimiere ich die Nutzung meiner öffentlichen IPv4-Adressen in Amazon VPC?

Behebung

Hinweis: Wenn du beim Ausführen von AWS Command Line Interface (AWS CLI)-Befehlen Fehlermeldungen erhältst, findest du weitere Informationen dazu unter Problembehandlung bei der AWS CLI. Stelle außerdem sicher, dass du die neueste Version der AWS CLI verwendest.

Für alle öffentlichen IPv4-Adressen fällt pro Stunde eine Gebühr von 0,005 USD für jede IP-Adresse an, unabhängig davon, ob sie an einen Service angeschlossen ist oder nicht. Wenn du ein Kunde des kostenlosen AWS-Kontingents für Amazon Elastic Compute Cloud (Amazon EC2) bist, erhältst du 750 kostenlose Nutzungsstunden. Diese kostenlose Nutzung gilt, wenn du eine Amazon EC2-Instance mit einer öffentlichen IPv4-Adresse startest.

Einblicke in öffentliche IPs aktivieren

Du kannst Einblicke in öffentliche IPs verwenden, um die öffentlichen IPv4-Adressen, die die Services derzeit in allen AWS-Regionen verwenden, zu überwachen, zu analysieren und zu prüfen.

Um Eiblicke in öffentliche IPs zu aktivieren, erstelle einen Amazon VPC IP Address Manager (IPAM)-Pool. Um die Nutzung öffentlicher IPv4-Adressen zu ermitteln, integriere IPAM Einblicke in öffentliche IPs in ein einzelnes AWS-Konto oder in die AWS Organizations-Konten.

Hinweis: Im Rahmen des kostenlosen Kontingents fallen für Einblicke in öffentliche IPs keine Kosten an. Preisinformationen für die Advanced-Stufe findest du auf der Amazon VPC-Preisseite auf der Registerkarte „IPAM“. Wenn du IPAM in Organizations integrierst, kannst du Einblicke in öffentliche IPs für alle Regionen und Konten in der Organisation nutzen, auch im kostenlosen Kontingent.

Um die Ergebnisse anzuzeigen, kannst du die Amazon VPC-Konsole oder die AWS-CLI verwenden.

Hinweis: Nachdem du einen IPAM-Pool erstellt hast, generieren Einblicke in öffentliche IPs einen Bericht für die öffentlichen IPv4-Adressen. Die Zeit, die für die Erstellung des Berichts benötigt wird, hängt von der Größe der Organisation ab.

Den Kosten- und Nutzungsbericht aktivieren

Der AWS-Kosten- und Nutzungsbericht (CUR) enthält Nutzungsdaten sowohl für verwendete als auch für ungenutzte öffentliche IPv4-Adressen. Wenn du den CUR erstellst, wähle Ressourcen-IDs einbeziehen aus, um eine detaillierte Analyse auf Ressourcenebene zu erhalten. Nachdem du den CUR erstellt hast, aktualisiert AWS die Berichtsdateien, die Daten für den bisherigen Monat enthalten, mindestens einmal täglich. Du kannst die Berichtsdateien verwenden, um historische IPv4-Adressnutzungsdaten zu analysieren.

Hinweis: Du kannst über einen Amazon Simple Storage Service (Amazon S3)-Bucket auf die Berichte zugreifen. Es kann bis zu 24 Stunden dauern, bis AWS Berichte an den Amazon S3-Bucket übermittelt.

Sofort öffentliche IPv4-Adressen identifizieren

Hinweis: Es ist eine bewährte Methode, CUR und Einblicke in öffentlich IPs für die geplante Analyse der Nutzung öffentlicher IPv4-Adressen zu verwenden.

Verwende die Amazon EC2-Konsole oder die AWS-CLI, um Services, die öffentliche IPv4-Adressen verwenden, sofort zu identifizieren.

Amazon-EC2-Konsole

Gehe wie folgt vor, um die Netzwerkschnittstellen zu analysieren, um die AWS-Services anzuzeigen, die öffentliche IPv4-Adressen verwenden:

1. Öffne die Amazon-EC2-Konsole.
2. Wähle unter Netzwerk und Sicherheit im Navigationsbereich die Option Netzwerk-Schnittstellen.
3. Gib unter dem Filter Öffentliche IPv4-Adressen <*> ein, um die Elastic Network-Schnittstellen zu identifizieren, die die primäre öffentliche IPv4-Adresse verwenden.
4. Identifiziere anhand der Beschreibung der Netzwerkschnittstelle und des Schnittstellentyps den Service, der die öffentliche IPv4-Adresse verwendet.
5. Führe den folgenden Befehl aus, um alle öffentlichen und sekundären IP-Adressen mit Netzwerkschnittstellen in einer Region anzuzeigen:

   aws ec2 describe-network-interfaces --region example-region --query 'NetworkInterfaces[*].PrivateIpAddresses[?Association.PublicIp].Association.PublicIp[]' --output table

   **Hinweis:**Ersetze example-region durch deine Region.

Informationen zu öffentlichen IPv4-Adressen, die AWS Site-to-Site VPN verwendet, findest du unter Wie überprüfe ich den aktuellen Status meines VPN-Tunnels?

Informationen zu öffentlichen IPv4-Adressen, die dem standardmäßigen und benutzerdefinierten AWS Global Accelerator entsprechen, findest du unter Anzeigen der Accelerator.

Gehe wie folgt vor, um inaktive oder zugehörige Elastic IP-Adressen anzuzeigen:

1. Öffne die Amazon-EC2-Konsole.
2. Wähle im Navigationsbereich unter Netzwerk und Sicherheit die Option Elastic IPs.
3. Wähle eine Elastic IP-Adresse aus, um die Ressourcen anzuzeigen, die diese Elastric IP-Adresse verwenden.
   Hinweis: Weitere Informationen zur Verwendung findest du in den Feldern Netzwerkschnittstelle oder Instance.

Das Mitbringen eigener IP-Adressen (BYOIPs) ist kostenlos. AWS stellt Global Accelerator in der Region us-west-2 eine Rechnung.

AWS CLI

**Voraussetzungen:**Führe den AWS CLI-Befehl aws configure aus, um die Anmeldeinformationen festzulegen. Installiere außerdem Boto3. Weitere Informationen findest du unter Installieren von Boto3 auf der Boto3-Website.

Um Services, die öffentliche IPv4-Adressen verwenden, sofort zu identifizieren, führe die folgenden Schritte in einer AWS CloudShell- oder Linux-Umgebung aus:

1. Erstelle die folgenden Dateien:

   touch public_ipv4_recon.py

2. Führe den folgenden Befehl aus, um die Datei zu bearbeiten:

   vim public_ipv4_recon.py

3. Kopiere den folgenden Code, füge ihn in die Datei ein und speichere dann die Datei:

   #!/usr/bin/env python3
   import pprint
   import boto3, sys
   
   profile = boto3.Session(profile_name=sys.argv[1])
   aga = profile.client('globalaccelerator', region_name='us-west-2')
   ec2 = boto3.client('ec2')
   
   def global_public_ipv4_lookup(aga):
     try:
       # global accelerator
       next_token = None
       while True:
         if next_token:
           resource = aga.list_accelerators(
           NextToken = next_token
             )
         else:
           resource = aga.list_accelerators(
           )
         print('Describing world wide Global Accelerators...')
         print('Note: AWS Global Accelerators are billed in us-west-2....')
         print(f'Number of AGA: {len(resource["Accelerators"])}')
         print('-'*40)
         for item in resource["Accelerators"]:
           print(f'Name: {item["Name"]}')
           if 'IpSets' in item.keys():
             for ip in item["IpSets"][0]["IpAddresses"]:
               print(f'Public IPv4: {ip}')
           print(f'Status: {item["Status"]}')
           print()
         next_token = resource.get("NextToken")
         if next_token is None:
           break
       print()
       # custom_routing_accelerators
       next_token = None
       while True:
         if next_token:
           custom_routing = aga.list_custom_routing_accelerators(
             NextToken = next_token
           )
         else:
           custom_routing = aga.list_custom_routing_accelerators(
           )
         print('Describing world wide Custom Routing Accelerators...')
         print('Note: AWS Global Accelerators are billed in us-west-2....')
         print(f'Number of custom AGA: {len(custom_routing["Accelerators"])}')
         print('-'*40)
         for item in custom_routing["Accelerators"]:
           if 'IpSets' in item.keys():
             for ip in item["IpSets"][0]["IpAddresses"]:
               print(f'Public IPv4: {ip}')
           print(f'Status: {item["Status"]}')
           print()
         next_token = custom_routing.get("NextToken")
         if next_token is None:
           break
       print()
     except Exception as err:
       print(f'Error found: {err}...')
       pass
   
   def public_ipv4_lookup(ec2):
     try:
       # vpn
       next_token = None
       while True:
         if next_token:
           vpn = ec2.describe_vpn_connections(
                 NextToken = next_token
           )
         else:
           vpn = ec2.describe_vpn_connections(
           )
         print('Describing VPNs...')
         print(f'Number of Vpn connections: {len(vpn["VpnConnections"])}')
         print('-'*40)
         for item in vpn["VpnConnections"]:
           if 'VpnConnectionId' in item.keys():
             print(f'Vpn Id: {item["VpnConnectionId"]}')
             for ip in item["VgwTelemetry"]:
               print(f'Public ipv4: {ip["OutsideIpAddress"]}')
           print()
         next_token = vpn.get("NextToken")
         if next_token is None:
           break
       print()
       # elastic ip
       eip = ec2.describe_addresses(
       )
       print('Describing Elastic IPs...')
       print(f'Number of Elastic Ips: {len(eip["Addresses"])}')
       print('-'*40)
       for item in eip["Addresses"]:
         if 'AllocationId' in item.keys():
           print(f'Eip Id: {item["AllocationId"]}')
           print(f'Public ipv4: {item["PublicIp"]}')
           print()
       print()
       # network interfaces
       next_token = None
       while True:
         if next_token:
           interface = ec2.describe_network_interfaces(
           NextToken=next_token
             )
         else:
           interface = ec2.describe_network_interfaces(
           )
         print('Describing Network Interfaces...')
         print(f'Number of interfaces: {len(interface["NetworkInterfaces"])}')
         print('Only printing Interfaces with a public IPv4 address...')
         print('-'*40)
         for item in interface["NetworkInterfaces"]:
           for ip in item["PrivateIpAddresses"]:
             if 'Association' not in ip.keys():
               pass
             else:
               print(f'Interface Id: {item["NetworkInterfaceId"]}')
               print(f'Description: {item["Description"]}')
               print(f'Status: {interface["NetworkInterfaces"][0]["Status"]}')
               print(f'Public Ip: {ip["Association"]["PublicIp"]}\n')
         next_token = interface.get("NextToken")
         if next_token is None:
           break
     except Exception as err:
       print(f'Error found: {err}...')
       pass
   
   # Run code
   if len(sys.argv) < 3 or not sys.argv[2]:
     global_public_ipv4_lookup(aga)
     regions_list = ec2.describe_regions(
         AllRegions=False
     )
     for region in regions_list['Regions']:
       if region["OptInStatus"] == 'opted-in' or 'opt-in-not-required':
         print(f'\n**********-[{region["RegionName"]}]-**********\n')
         public_ipv4_lookup(
           ec2=profile.client('ec2', region_name=region["RegionName"])
           )
   elif sys.argv[2]:
     global_public_ipv4_lookup(aga)
     public_ipv4_lookup(
       ec2=profile.client('ec2', region_name=sys.argv[2])
       )

4. Führe den folgenden Befehl aus, um alle Regionen zu überprüfen:

   python3 public_ipv4_recon.py example-cli-profile

   Hinweis: Ersetze example-cli-profile durch den Namen des konfigurierten AWS-CLI-Profils oder einen beliebigen Profilnamen, der in der Datei .aws/credentials definiert ist. Wenn du Windows verwendest, ersetze python3 durch Python.
   -oder-
   Führe den folgenden Befehl aus, um eine bestimmte Region zu überprüfen:

   python3 public_ipv4_recon.py example-cli-profile example-region

   Hinweis: Ersetze example-cli-profile durch den Namen des konfigurierten AWS-CLI-Profils oder einen beliebigen Profilnamen, der in der Datei .aws/credentials definiert ist. Ersetze example-region durch die Region.

Wenn du nicht autorisiert bist, die Anfrage zu stellen, oder die Region für dein Konto deaktiviert ist, erhältst du möglicherweise die folgende Fehlermeldung:

„Error found: An error occurred (AuthFailure) when calling the <API> operation: AWS was not able to validate the provided access credentials...“

Die Nutzung öffentlicher IPv4-Adressen optimieren und IPv6-Adressen übernehmen

Um die Kosten zu optimieren, erweitere die aktuelle Architektur, um die Verwendung öffentlicher IPv4-Adressen zu minimieren. Es ist eine bewährte Methode, auf IPv6 zu migrieren. Für IPv6-Adressen fallen keine Gebühren an.