S3 golang Multipart upload using Presigned url

We are writing an application in "go" language where I generate a Presigned url from my service (using PutObjectRequest() and Presign()) and pass it to an external service so that the external service can perform the multipart upload of larger files to S3 (using presigned url). We do not want to give the AWS credentials to the external service, that is why we plan to provide a presigned url. Also, since the files are large we need to use the multipart upload feature provided by AWS SDK.

I did a quick search and could not find any functions that do this in the aws sdk.
Does the AWS sdk for go language support multipart upload using presigned url? Is there any way to achieve this?

Create the request to Amazon to get an UploadID for multipart, create several parts from it and pre-sign each normally. Send these to the client to use them.

func (s *s3) UploadMultipartPresignedCreate(key string) ([]string) {
  // Query with bucket and key to fetch UploadID
	out, err := s.s3.CreateMultipartUploadRequest(&s3.CreateMultipartUploadInput{
		Bucket: &s.bucketName,
		Key:    aws.String(key),
	})

	if err != nil {
		return nil
	}

  // Generate parts
	var parts = 10 // Number of parts
	requests := make([]string, 0, parts)

	for i := 0; i < parts; i++ {
		req, _ := i.s3.UploadPartRequest(&s3.UploadPartInput{
			Bucket:     &s.bucketName,
			Key:        aws.String(key),
			PartNumber: aws.Int64((int64)(i)),
			UploadId:   out.UploadId,
		})

    // Presign each time with whatever expiration time you want
		url, err := req.Presign(time.Hour)

		if err != nil {
			return nil
		}

		requests = append(requests, url)
	}

  // Returning a list of presigned URLs
	return requests, nil
}

At this point the client should succeed or fail their upload and ping you back with completion of process (on a separate endpoint, typically). At this point you'll want to carry out the Upload completion.

func (s *S3) UploadMultipartComplete(key string, uploadId string) (string) {
	out, err := s.s3.CompleteMultipartUpload(&s3.CompleteMultipartUploadInput{
		Bucket:   &s.bucketName,
		Key:      aws.String(key),
		UploadId: aws.String(uploadId),
	})

	if err != nil {
		return "" // Give a reasonable error
	}

	return *out.Key, nil
}

If the client informs you that for whatever reason (possibly expiry, or change of mind) the multipart upload has failed, you can instead abort the multipart (and you should, since you'll be charged until it expires). This would be done in place of the CompleteMultipartUpload above.

out, err := i.s3.AbortMultipartUpload(&s3.AbortMultipartUploadInput{
	Bucket:   &i.bucketName,
	Key:      aws.String(key),
	UploadId: aws.String(uploadId),
})

The AWS Go SDK documentation provides a spelled out example of using presigned PUT URLs for uploading: https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/s3-example-presigned-urls.html

For example (copied relevant part from the documentation)

    // Create S3 service client
    svc := s3.New(sess)

    resp, _ := svc.PutObjectRequest(&s3.PutObjectInput{
        Bucket: aws.String("testBucket"),
        Key:    aws.String("testKey"),
    })

    md5s := base64.StdEncoding.EncodeToString(h.Sum(nil))
    resp.HTTPRequest.Header.Set("Content-MD5", md5s)

    url, err := resp.Presign(15 * time.Minute)
    if err != nil {
        fmt.Println("error presigning request", err)
        return
    }

    req, err := http.NewRequest("PUT", url, strings.NewReader(""))
    req.Header.Set("Content-MD5", md5s)
    if err != nil {
        fmt.Println("error creating request", url)
        return
    }