get signed url for S3 object

signedUrl.go

package main

import (
	"cluster-manager/constants"
	"crypto/tls"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/credentials"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/s3"
	"github.com/urfave/cli"
	"log"
	"net/http"
	"os"
	"strings"
	"time"
)

func main() {

	var access_key string
	var access_secret string
	var region string
	var path string
	var duration int

	app := cli.NewApp()

	app.Flags = []cli.Flag{
		cli.StringFlag{
			Name:        "key",
			Usage:       "AWS access key",
			Destination: &access_key,
			EnvVar:      "AWS_ACCESS_KEY_ID",
		},
		cli.StringFlag{
			Name:        "secret",
			Usage:       "AWS secret key",
			Destination: &access_secret,
			EnvVar:      "AWS_SECRET_ACCESS_KEY",
		},
		cli.StringFlag{
			Name:        "region",
			Usage:       "AWS region",
			Destination: &region,
			Value:       "us-east-1",
			EnvVar:      "AWS_DEFAULT_REGION",
		},
		cli.StringFlag{
			Name:        "path",
			Usage:       "S3 object path including bucket name",
			Destination: &path,
		},
		cli.IntFlag{
			Name:        "duration",
			Usage:       "Duration in minutes for URL to remain available",
			Value:       1440,
			Destination: &duration,
		},
	}

	app.Action = func(c *cli.Context) error {

		if len(access_key) > 0 && len(access_secret) > 0 && len(path) > 0 {

			url, err := get_presign_url(access_key, access_secret, path, region, duration)

			if err != nil {
				log.Println(err)
				return nil
			}

			log.Println("Signed URL valid for", duration, "minutes")
			log.Println(url)
		} else {
			log.Println("access_key, access_secret or path is empty")
		}

		return nil
	}

	err := app.Run(os.Args)
	if err != nil {
		log.Println(err)
	}

}

func get_presign_url(access_key, access_secret, path, region string, duration int) (string, error) {
	creds := credentials.NewStaticCredentials(access_key, access_secret, "")
	client := &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{RootCAs: constants.Pool}}}
	service := s3.New(session.New(&aws.Config{Region: &region, Credentials: creds, HTTPClient: client}))

	bucket, key := get_bucket_and_key(path)

	req, _ := service.GetObjectRequest(&s3.GetObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(key),
	})
	urlStr, err := req.Presign(time.Duration(duration) * time.Minute)

	if err != nil {
		return urlStr, err
	}

	return urlStr, nil
}

func get_bucket_and_key(in string) (bucket, key string) {

	tokenized := strings.Split(in, "/")
	bucket = tokenized[0]
	key = strings.Join(tokenized[1:], "/")
	return
}