import requests

# The base URL for the instance metadata service
METADATA_URL = "http://169.254.169.254/latest/meta-data/"

def crawl_metadata_service(url, depth=1):
    try:
        response = requests.get(url)
        response.raise_for_status()

        # If content is not plain text, treat it as a JSON object.
        if "application/json" in response.headers.get('Content-Type', ''):
            return response.json()

        # Get the content as text
        content = response.text
        items = content.splitlines()

        # If it's a single item, it might be a leaf node
        if len(items) == 1 and depth > 0:
            print(f"{url[len(METADATA_URL):]}: {items[0]}")
            return
        
        # For each item, check if it's a directory (ends with /) or a leaf node
        for item in items:
            if item.endswith("/"):
                crawl_metadata_service(url + item, depth + 1)
            else:
                print(f"{url + item}: ", end="")
                crawl_metadata_service(url + item, 0)

    except requests.exceptions.RequestException as e:
        print(f"Error accessing {url}: {str(e)}")

def main():
    print("Crawling EC2 Instance Metadata:")
    crawl_metadata_service(METADATA_URL)

if __name__ == "__main__":
    main()

  pip install requests
  

import requests

def get_metadata(recursive=True):
    # The IP address for the instance metadata service.
    metadata_url = "http://169.254.169.254/latest/meta-data/"
    
    if recursive:
        return requests.get(metadata_url + '?recursive=true').json()
    else:
        response = requests.get(metadata_url)
        response.raise_for_status()
        return response.text.splitlines()

def fetch_metadata():
    # Checking variables to see which type of request to make
    recursive = True # Use this if AWS version 1.2 is enough

    # Start collecting metadata recursively from the base URL
    metadata = get_metadata(recursive)

    if recursive:
        return metadata
    else:
        # For non-recursive, we need to iterate through
        data = {}
        for item in metadata:
            url = metadata_url + item
            result = requests.get(url)
            if item.endswith('/'):
                sub_items = requests.get(url+'?recursive=true').json()
                data[item[:-1]] = sub_items
            else:
                data[item] = result.text
        return data

def main():
    try:
        metadata = fetch_metadata()
        print(metadata)

    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    main()

    pip install requests
    

import requests

# The base URL for the EC2 instance metadata service
METADATA_URL = "http://169.254.169.254/latest/meta-data/"

def fetch_metadata(token, url=METADATA_URL):
    response = requests.get(
        url, 
        headers={'X-aws-ec2-metadata-token': token} if token else {}
    )
    response.raise_for_status()  # Check for HTTP request errors
    return response.text.splitlines()

def get_metadata():
    try:
        # First, attempt to get a token for IMDSv2
        token = requests.put(
            "http://169.254.169.254/latest/api/token",
            headers={'X-aws-ec2-metadata-token-ttl-seconds': '21600'}
        ).text

        all_metadata = {}

        # Recursively fetch all metadata items
        def recursive_fetch(url):
            metadata_items = fetch_metadata(token, url)
            for item in metadata_items:
                item_url = url + item
                if item.endswith("/"):
                    recursive_fetch(item_url)
                else:
                    all_metadata[item_url.replace(METADATA_URL, '')] = fetch_metadata(token, item_url)[0]

        recursive_fetch(METADATA_URL)

        return all_metadata

    except requests.exceptions.RequestException as e:
        print(f"Failed to retrieve metadata: {e}")
        return {}

if __name__ == "__main__":
    metadata = get_metadata()
    for key, value in metadata.items():
        print(f"{key}: {value}")

import requests

# Define the base URL for the instance metadata service
IMDS_BASE_URL = "http://169.254.169.254/latest"

# Initialize a session for HTTP requests
session = requests.Session()

def get_token():
    """Get a token for authenticating with IMDSv2."""
    headers = {"X-aws-ec2-metadata-token-ttl-seconds": "21600"}  # Token valid for 6 hours
    response = session.put(f"{IMDS_BASE_URL}/api/token", headers=headers)
    response.raise_for_status()  # Raise an error if the request failed
    return response.text

def crawl_metadata():
    """Crawl all instance metadata."""
    token = get_token()
    headers = {"X-aws-ec2-metadata-token": token}
    
    def fetch_metadata(path):
        """Recursively fetch metadata."""
        response = session.get(f"{IMDS_BASE_URL}/meta-data{path}", headers=headers)
        response.raise_for_status()
        
        if response.headers.get("Content-Type") == "text/plain":
            if path.endswith("/"):
                # Recursive call for paths that signify directories
                items = response.text.splitlines()
                return {item.rstrip('/'): fetch_metadata(f"{path}{item.rstrip('/')}") for item in items}
            else:
                return response.text
        else:
            return response.text

    # Start crawling from the root
    return fetch_metadata("/")

def main():
    try:
        metadata = crawl_metadata()
        print(metadata)  # Print or process the collected metadata
    except requests.RequestException as e:
        print(f"Error fetching metadata: {e}")

if __name__ == "__main__":
    main()

  pip install requests
  

import requests

def get_metadata(base_url='http://169.254.169.254/latest/meta-data/', indent=''):
    response = requests.get(base_url)
    response.raise_for_status()
    metadata = {}

    for item in response.text.splitlines():
        if item.endswith('/'):
            metadata[item[:-1]] = get_metadata(base_url + item, indent + '    ')
        else:
            item_url = base_url + item
            item_response = requests.get(item_url)
            item_response.raise_for_status()
            metadata[item] = item_response.text
            
    return metadata

def print_metadata(metadata, indent=''):
    for key, value in metadata.items():
        if isinstance(value, dict):
            print(f"{indent}{key}/")
            print_metadata(value, indent + '    ')
        else:
            print(f"{indent}{key}: {value}")

def main():
    metadata = get_metadata()
    print_metadata(metadata)

if __name__ == '__main__':
    main()

python ec2_metadata.py