tessl/golang-github-com--aws--aws-sdk-go-v2

AWS SDK for Go v2 with 130+ service clients, Request/Send pattern, and context support.

Overview

Eval results

Files

Quick Start Guide

Name: tessl/golang-github-com--aws--aws-sdk-go-v2
Author: tessl

Installation

# Using dep (recommended for v0.4.0)
dep ensure -add github.com/aws/aws-sdk-go-v2

# Or using go get
go get github.com/aws/aws-sdk-go-v2

# For specific service
go get github.com/aws/aws-sdk-go-v2/service/s3

Setup AWS Credentials

Option 1: Environment Variables

export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_REGION=us-east-1
export AWS_SESSION_TOKEN=token  # Optional, for temporary credentials

Option 2: Shared Config Files

~/.aws/credentials:

[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

[production]
aws_access_key_id = AKID_PROD
aws_secret_access_key = SECRET_PROD

~/.aws/config:

[default]
region = us-east-1
output = json

[profile production]
region = eu-west-1

Option 3: IAM Role (EC2/ECS/Lambda)

No configuration needed - credentials automatically loaded from instance/task metadata.

Option 4: Programmatic

cfg := aws.Config{
    Region:      "us-west-2",
    Credentials: aws.NewStaticCredentialsProvider("AKID", "SECRET", ""),
}

Minimal S3 Example

package main

import (
    "fmt"
    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/aws/external"
    "github.com/aws/aws-sdk-go-v2/service/s3"
)

func main() {
    // Load config
    cfg, err := external.LoadDefaultAWSConfig()
    if err != nil {
        panic("config load error: " + err.Error())
    }
    
    // Override region if needed
    cfg.Region = "us-east-1"
    
    // Create S3 client
    svc := s3.New(cfg)
    
    // Make request
    req := svc.ListBucketsRequest(&s3.ListBucketsInput{})
    
    // Send request
    resp, err := req.Send()
    if err != nil {
        panic("request error: " + err.Error())
    }
    
    // Use response
    for _, bucket := range resp.Buckets {
        fmt.Println(*bucket.Name)
    }
}

Upload File to S3

import (
    "os"
    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/aws/external"
    "github.com/aws/aws-sdk-go-v2/service/s3"
)

func uploadFile(filename, bucket, key string) error {
    cfg, err := external.LoadDefaultAWSConfig()
    if err != nil {
        return err
    }
    
    svc := s3.New(cfg)
    
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()
    
    // Get file size for Content-Length
    stat, _ := file.Stat()
    
    req := svc.PutObjectRequest(&s3.PutObjectInput{
        Bucket:        aws.String(bucket),
        Key:           aws.String(key),
        Body:          file,
        ContentLength: aws.Int64(stat.Size()),
    })
    
    _, err = req.Send()
    return err
}

Download File from S3

import "io"

func downloadFile(bucket, key, filename string) error {
    cfg, _ := external.LoadDefaultAWSConfig()
    svc := s3.New(cfg)
    
    req := svc.GetObjectRequest(&s3.GetObjectInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(key),
    })
    
    resp, err := req.Send()
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    file, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer file.Close()
    
    _, err = io.Copy(file, resp.Body)
    return err
}

Use Specific Profile

cfg, err := external.LoadDefaultAWSConfig(
    external.WithSharedConfigProfile("production"),
)

DynamoDB Get Item

import "github.com/aws/aws-sdk-go-v2/service/dynamodb"

func getItem(tableName, id string) (map[string]dynamodb.AttributeValue, error) {
    cfg, _ := external.LoadDefaultAWSConfig()
    svc := dynamodb.New(cfg)
    
    req := svc.GetItemRequest(&dynamodb.GetItemInput{
        TableName: aws.String(tableName),
        Key: map[string]dynamodb.AttributeValue{
            "id": {S: aws.String(id)},
        },
    })
    
    resp, err := req.Send()
    if err != nil {
        return nil, err
    }
    
    return resp.Item, nil
}

DynamoDB Put Item

func putItem(tableName, id, name string) error {
    cfg, _ := external.LoadDefaultAWSConfig()
    svc := dynamodb.New(cfg)
    
    req := svc.PutItemRequest(&dynamodb.PutItemInput{
        TableName: aws.String(tableName),
        Item: map[string]dynamodb.AttributeValue{
            "id":   {S: aws.String(id)},
            "name": {S: aws.String(name)},
        },
    })
    
    _, err := req.Send()
    return err
}

Invoke Lambda Function

import (
    "encoding/json"
    "github.com/aws/aws-sdk-go-v2/service/lambda"
)

func invokeLambda(functionName string, payload interface{}) ([]byte, error) {
    cfg, _ := external.LoadDefaultAWSConfig()
    svc := lambda.New(cfg)
    
    payloadBytes, _ := json.Marshal(payload)
    
    req := svc.InvokeRequest(&lambda.InvokeInput{
        FunctionName: aws.String(functionName),
        Payload:      payloadBytes,
    })
    
    resp, err := req.Send()
    if err != nil {
        return nil, err
    }
    
    return resp.Payload, nil
}

List EC2 Instances

import "github.com/aws/aws-sdk-go-v2/service/ec2"

func listInstances() error {
    cfg, _ := external.LoadDefaultAWSConfig()
    svc := ec2.New(cfg)
    
    req := svc.DescribeInstancesRequest(&ec2.DescribeInstancesInput{})
    resp, err := req.Send()
    if err != nil {
        return err
    }
    
    for _, reservation := range resp.Reservations {
        for _, instance := range reservation.Instances {
            fmt.Printf("%s: %s\n", *instance.InstanceId, instance.State.Name)
        }
    }
    
    return nil
}

Send SQS Message

import "github.com/aws/aws-sdk-go-v2/service/sqs"

func sendMessage(queueURL, message string) error {
    cfg, _ := external.LoadDefaultAWSConfig()
    svc := sqs.New(cfg)
    
    req := svc.SendMessageRequest(&sqs.SendMessageInput{
        QueueUrl:    aws.String(queueURL),
        MessageBody: aws.String(message),
    })
    
    _, err := req.Send()
    return err
}

With Context (Timeout)

import (
    "context"
    "time"
)

func withTimeout() error {
    cfg, _ := external.LoadDefaultAWSConfig()
    svc := s3.New(cfg)
    
    // Create context with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    // Create request
    req := svc.GetObjectRequest(&s3.GetObjectInput{
        Bucket: aws.String("bucket"),
        Key:    aws.String("key"),
    })
    
    // Set context
    req.SetContext(ctx)
    
    // Send - respects timeout
    resp, err := req.Send()
    if err != nil {
        if err == context.DeadlineExceeded {
            return fmt.Errorf("request timed out")
        }
        return err
    }
    
    defer resp.Body.Close()
    return nil
}

Error Handling Pattern

import (
    "fmt"
    "github.com/aws/aws-sdk-go-v2/aws/awserr"
    "github.com/aws/aws-sdk-go-v2/service/s3"
)

func handleErrors() error {
    cfg, _ := external.LoadDefaultAWSConfig()
    svc := s3.New(cfg)
    
    req := svc.GetObjectRequest(&s3.GetObjectInput{
        Bucket: aws.String("bucket"),
        Key:    aws.String("key"),
    })
    
    resp, err := req.Send()
    if err != nil {
        // Type assert to AWS error
        if aerr, ok := err.(awserr.Error); ok {
            // AWS-specific error
            fmt.Printf("AWS Error Code: %s\n", aerr.Code())
            fmt.Printf("AWS Error Message: %s\n", aerr.Message())
            
            // Check specific error codes
            switch aerr.Code() {
            case s3.ErrCodeNoSuchBucket:
                return fmt.Errorf("bucket does not exist")
            case s3.ErrCodeNoSuchKey:
                return fmt.Errorf("object does not exist")
            case "AccessDenied":
                return fmt.Errorf("insufficient permissions")
            }
            
            // Get HTTP details if available
            if reqErr, ok := err.(awserr.RequestFailure); ok {
                fmt.Printf("HTTP Status: %d\n", reqErr.StatusCode())
                fmt.Printf("Request ID: %s\n", reqErr.RequestID())
            }
        }
        
        // Generic error
        return fmt.Errorf("request failed: %w", err)
    }
    
    defer resp.Body.Close()
    return nil
}

Next Steps

Real-World Scenarios - Complete examples with all services
Reference Documentation - Complete API specifications
S3 Reference - All S3 operations
DynamoDB, Lambda, EC2, SQS, SNS - Other services

Install with Tessl CLI

npx tessl i tessl/golang-github-com--aws--aws-sdk-go-v2

docs

examples

guides

quick-start.md

reference

index.md

tile.json