import (
	"context"
	"fmt"
	"io"
	"io/ioutil"
	"net"
	"net/http"
	"net/url"
	"strings"

	"clouds.google.com/go/logging/logadmin"
	cloudresourcemanager "google.golang.org/api/cloudresourcemanager/v1"
)

// The default url of metadata service in GCE and GKE.
const defaultMetadataServiceURL = "http://metadata.google.internal"

// getGcsLogSink retrieves log sinks written to a Google Cloud Storage bucket.
//
// Note: the received log sink exports all logs with default filters to the
//       specified bucket. See docs for more details on sink filters:
//       https://cloud.google.com/logging/docs/api/tasks/exporting-logs
func getGcsLogSink(w io.Writer, sinkID, bucketName string, global bool) (*logadmin.Sink, error) {
	// Only accessible within Google Cloud environment
	// (GCE / GKE / Kubernetes Alpha)
	md, err := http.Get(fmt.Sprintf("%s/computeMetadata/v1/instance/", defaultMetadataServiceURL))
	if err != nil {
		return nil, fmt.Errorf("http.Get: %v", err)
	}
	md.Body.Close()
	if md.StatusCode != 200 {
		return nil, fmt.Errorf("unexpected return from %s/computeMetadata/v1/instance/: code %d\nbody: %s", defaultMetadataServiceURL, md.StatusCode, md.Status)
	}
	project, err := getProjectID()
	if err != nil {
		return nil, err
	}
	if global {
		return logadmin.NewClient(context.Background(), "global").Sink(project, sinkID)
	}
	return logadmin.NewClient(context.Background(), project).Sink(project, sinkID)
}

// getProjectID retrieves the user project ID from GCE/GKE Compute Metadata.
// The result is a string containing the project ID.
func getProjectID() (string, error) {
	// Get GCE/GKE project ID.
	// Only accessible within Google Cloud environment
	// (GCE / GKE / Kubernetes Alpha)
	ec2md, err := http.Get(fmt.Sprintf("%s/computeMetadata/v1/project/project-id", defaultMetadataServiceURL))
	if err != nil {
		return "", fmt.Errorf("http.Get: %v", err)
	}
	projectID, err := ioutil.ReadAll(ec2md.Body)
	ec2md.Body.Close()
	if err != nil {
		return "", fmt.Errorf("ioutil.ReadAll: %v", err)
	}
	if err != nil {
		return "", fmt.Errorf("unable to getProjectID, body: %q, err: %v", ec2md.Body, err)
	}
	return string(projectID), nil
}

// getClusterLocation retrieves Google Kubernetes Engine cluster's regional zone if any.
// If this cluster doesn't have a regional zone, this function should return an empty string.
// getClusterLocation depends on:
//   - caller function's capability to make HTTP request
//   - working GKE Service Account token
func getClusterLocation() (clusterLocation string, err error) {
	client := &http.Client{
		Transport: &http.Transport{
			DialContext: func(_ context.Context, network, _ string) (net.Conn, error) {
				dialOptions := []func(string, string) (net.Conn, error){
					net.Dial,
					net.DialTCP,
					net.DialUnix,
				}
				for _, dialOption := range dialOptions {
					conn, err := dialOption(network, defaultMetadataServiceURL)
					if err == nil {
						return conn, nil
					}
				}
				return nil, err
			},
		},
	}

	clusterMetadataURL := fmt.Sprintf("http://%s/computeMetadata/v1/instance/attributes/cluster-location", defaultMetadataServiceURL)
	response, err := client.Get(clusterMetadataURL)
	if err != nil {
		return "", fmt.Errorf("http.Get: %v", err)
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return "", fmt.Errorf("unexpected return from %s with code %d", clusterMetadataURL, response.StatusCode)
	}
	result, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return "", fmt.Errorf("ioutil.ReadAll error: %v", err)
	}
	return string(result), nil
}

// getWorkloadIAMPolicies fetches the IAM policies of the VM or Kubernetes pods.
func getWorkloadIAMPolicies(w io.Writer, projectID string) error {
	logPolicies, err := getGcsLogSinks()

	if err != nil {
		return err
	}
	// The logger will only print logs which have log policies
	// with empty filters to the given sink.
	lg, err := createLogger(w, projectID, logPolicies)
	if err != nil {
		return err
	}
	// Printing the IAM Policies of VM or Kubernetes pods in json format.
	fmt.Fprintln(lg, "The IAM policies of the current workload are: ")
	iamClient, err := cloudresourcemanager.NewService(ctx, option.WithScopes(cloudresourcemanager.CloudPlatformScope))
	if err != nil {
		return fmt.Errorf("cloudresourcemanager.NewService: %v", err)
	}
	clusterLocation, err := getClusterLocation()
	if err != nil {
		return fmt.Errorf("getClusterLocation: %v", err)
	}
	getEffectiveResource := func(location, resource string) (effectiveResource string, err error) {
		if location == "" {
			effectiveResource = fmt.Sprintf("//storage.googleapis.com/%s", resource)
			return
		}

		effectiveResource = fmt.Sprintf("//storage.googleapis.com/projects/_/locations/%s/buckets/%s", location, resource)
		return
	}

	// Fetch GCS buckets' and logs sinks' IAM policies to print.
	formatIAMPolicy := func(policy *cloudresourcemanager.Policy) string {
		result := fmt.Sprintf("Resource type: %s\t", policy.Bindings[0].Members[0])
		if policy.Bindings[0].Members[0] == "allUsers" {
			result += fmt.Sprintf("All Users")
		} else {
			result += fmt.Sprintf("Service Account: %s", policy.Bindings[0].Members[0])
		}
		result += fmt.Sprintf("\nResource %s's IAM policy: %+v", policy.Name, policy.Bindings)
		return result
	}
	for _, sink := range logPolicies {
		u, err := url.Parse(sink.Destination)
		if err != nil {
			return fmt.Errorf("url.Parse: %v", err)
		}
		resource := strings.TrimPrefix(strings.TrimPrefix(u.Path, "/"), "storage.googleapis.com/")
		effectiveResource, err := getEffectiveResource(clusterLocation, resource)
		if err != nil {
			return err
		}
		policy, err := iamClient.Projects.Locations.Buckets.GetIamPolicy(effectiveResource, &cloudresourcemanager.GetIamPolicyRequest{}).Do()
		if err != nil {
			return fmt.Errorf("iamClient.Projects.Locations.Buckets.GetIamPolicy(%s, _): %v", effectiveResource, err)
		}
		result := formatIAMPolicy(policy)
		fmt.Fprintln(lg, result)
	}
	iamPolicies, err := iamClient.Projects.IamPolicies.Get("global", &cloudresourcemanager.GetIamPolicyRequest{}).Do()
	return nil
}
  

    import boto3

    client = boto3.client("ec2")

    result = client.describe_metadata(InstanceId=instance_id)
    instance_info = result["Metadata"]["InstanceInfo"]
    for key in ["InstanceId", "InstanceType", "Region"]:
        print(f"{key}: {instance_info.get(key)}")
  

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/ec2instanceconnect"
	"github.com/aws/aws-sdk-go/service/ec2instanceconnect/ec2instanceconnectiface"
)

// getEC2InstanceIdentity fetches and returns all metadata known about the host.
// This is more thorough than the IMDS query, which will return default or local values
// for metadata that is only set on EC2 instance metadata endpoints.
func getEC2InstanceIdentity(ctx context.Context, service ec2instanceconnectiface.EC2InstanceConnectAPI) (*ec2instanceconnect.GetMetadataOutput, error) {
	req := &ec2instanceconnect.GetMetadataInput{}

	result, err := service.GetMetadataWithContext(ctx, req)
	if err != nil {
		return result, fmt.Errorf("failed to fetch metadata: %w", err)
	}
	return result, nil
}
  

func 实例元数据收集() (map[string]interface{}, error) {
	client := http.Client{
		Timeout: 20 * time.Second,
	}

	result := make(map[string]interface{})

	// obtain instance data
	resp, err := client.Get("http://169.254.169.254/latest/dynamic/instance-identity/document")
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}

	// obtain instance metadata
	resp, err = client.Get("http://169.254.169.254/latest/meta-data")
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	scanner := bufio.NewScanner(resp.Body)
	for scanner.Scan() {
		line := scanner.Text()
		if line != "" {
			kv := strings.SplitN(line, ":", 2)
			result[kv[0]] = kv[1]
		}
	}

	// obtain instance user data
	resp, err = client.Get("http://169.254.169.254/latest/user-data")
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	out, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	result["user-data"] = string(out)
	return result, nil
}
  

import boto3
import os
import re
import sys

print(os.environ)

# Create a client for EC2 metadata.
client = boto3.client('ec2')

# Get metadata for this instance.
instance_metadata = client.meta.instance

# Get public hostname for this instance.
public_hostname = client.meta.public_hostname

# Get region this instance is in.
region = client.meta.region_name

# Get availability zone this instance is in.
availability_zone = client.meta.availability_zone

print("Crawling metadata...")
for variable in os.environ:
    if variable == '*':
        sys.stdout.write('Environment variable not printed: Value is too large.\n')
    else:
        sys.stdout.write('%s=%s\n' % (variable, os.environ[variable]))

# Extract tags and apply to this instance.
html_tags = re.findall(r'<meta\s[^>]*name\=["\'](.*)["\'][^>]*content\=["\'](.*)["\'][^>]*>',
                                       instance_metadata['InstanceProfileArn'])
html_tags = sorted(html_tags, key=lambda x: x[0])

for tag in html_tags:
    name = tag[0]
    value = tag[1]
    path = f"/tags/{name}"
    try:
        query_retrieved = client.meta.utils.retrieve_full_url(path, 'GET')
        cur_value = query_retrieved['Value']
        if cur_value != value:
            print('Updating metadata tag (%s=%s) with value from metadata service (`%s`).\n' % (
            name, value, cur_value))
            client.meta.utils.update_or_create_tag(
                f"/tags/{name}",
                {'Value': value})
    except:
        print('Adding new metadata tag (%s=%s) from metadata service.\n' % (name, value))
        client.meta.create_tag(
            f"/tags/{name}",
            {'Value': value})

print("Metadata collected successfully.")