Upload a struct or object to S3 bucket using GoLang?

I am working with the AWS S3 SDK in GoLang, playing with uploads and downloads to various buckets. I am wondering if there is a simpler way to upload structs or objects directly to the bucket?

I have a struct representing an event:

type Event struct {
	ID               string
	ProcessID        string                 
	TxnID            string
    Inputs           map[string]interface{}                      
}

That I would like to upload into the S3 bucket. But the code that I found in the documentation only works for uploading strings.

func Save(client S3Client, T interface{}, key string) bool {
    svc := client.S3clientObject
    input := &s3.PutObjectInput{
        Body: aws.ReadSeekCloser(strings.NewReader("testing this one")),
        Bucket: aws.String(GetS3Bucket()),
        Key: aws.String(GetObjectKey(T, key)),
        Metadata: map[string]*string{
            "metadata1": aws.String("value1"),
            "metadata2": aws.String("value2"),
        },

    }

This is successful in uploading a basic file to the S3 bucket that when opened simply reads "testing this one". Is there a way to upload to the bucket so that it is uploading an object rather than simply just a string value??

Any help is appreciated as I am new to Go and S3.

edit

This is the code I'm using for the Get function:

func GetIt(client S3Client, T interface{}, key string) interface{} {
    svc := client.S3clientObject
    s3Key := GetObjectKey(T, key)
    resp, err := svc.GetObject(&s3.GetObjectInput{
        Bucket: aws.String(GetS3Bucket()),
        Key: aws.String(s3Key),
    })
    if err != nil {
        fmt.Println(err)
        return err
    }    
    result := json.NewDecoder(resp.Body).Decode(&T)
    fmt.Println(result) 
    return json.NewDecoder(resp.Body).Decode(&T)
}

func main() {
    client := b.CreateS3Client()
    event := b.CreateEvent()
    GetIt(client, event, key)
}

Encode the value as bytes and upload the bytes. Here's how to encode the value as JSON bytes:

func Save(client S3Client, value interface{}, key string) error {

    p, err := json.Marshal(value)
    if err != nil {
	    return err
	}
	input := &s3.PutObjectInput{
		Body:   aws.ReadSeekCloser(bytes.NewReader(p)),
		…
	}
	…
}

Call Save with the value you want to upload:

value := &Event{ID: "an id", …}
err := Save(…, value, …)
if err != nil {
  // handle error
}

There are many possible including including gob, xml and json, msgpack, etc. The best encoding format will depend on your application requirements.

Reverse the process when getting an object:

func GetIt(client S3Client, T interface{}, key string) error {
    svc := client.S3clientObject
    resp, err := svc.GetObject(&s3.GetObjectInput{
        Bucket: aws.String(GetS3Bucket()),
        Key: aws.String(key),
    })
    if err != nil {
        return err
    }    
    return json.NewDecoder(resp.Body).Decode(T)
}

Call GetIt with a pointer to the destination value:

var value model.Event
err := GetIt(client, &value, key)
if err != nil {
    // handle error
}
fmt.Println(value) // prints the decoded value.

The example cited here shows that S3 allows you to upload anything that implements the io.Reader interface. The example is using the strings.NewReader syntax create a io.Reader that knows how to provide the specified string to the caller. Your job (according to AWS here) is to figure out how to adapt whatever you need to store into an io.Reader.

You can store the bytes directly JSON encoded like this

package main

import (
	"bytes"
	"encoding/json"
)

type Event struct {
	ID               string
	ProcessID        string
	TxnID            string
	Inputs           map[string]interface{}
}

func main() {
	// To prepare the object for writing
	b, err := json.Marshal(event)
	if err != nil {
		return
	}
	// pass this reader into aws.ReadSeekCloser(...)
	reader := bytes.NewReader(b)
}