HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
aws
aws-sdk-go
Go2014–2024
aws / aws-sdk-go · Archived

aws-sdk-go

This SDK has reached end-of-support. The AWS SDK for Go v2 is available here: https://github.com/aws/aws-sdk-go-v2

18Distinct people
20Mentions
0Explicit recommenders
8.7KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

This SDK has reached end-of-support. The AWS SDK for Go v2 is available here: https://github.com/aws/aws-sdk-go-v2

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year20 dated mentions

Observed mentions: 2014-12-10 15:45:29 UTC to 2024-05-31 10:32:08 UTC.

0123452014-01-01 00:00:00 UTC to 2015-01-01 00:00:00 UTC (exclusive): 3 mentions; 1 submissions, 2 comments20142015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 5 mentions; 0 submissions, 5 comments2016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2024

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20142014-01-01 00:00:00 UTC2015-01-01 00:00:00 UTC312
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC505
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC303
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC101
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC101
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC101
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC000
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC202
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC202
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC101
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC101

What Hacker News says

20 sources
I'm... really not sure I agree with this, from a philosophical point of view. It feels like this is making "eh, we'll just upgrade our Go version next quarter" too easy; ultimately some responsibility toward updating your application's Go version to work with what new dependencies require should fall on Us, the application developers. Sure, we're bad at it. Everyone's lived through running years-old versions of some toolchain. But I think this just makes the problem worse, not better. Its compounded by the problem that, when you're setting up a new library, the `go` directive in the mod file defaults to your current toolchain; most likely a very current one. It would take a not-insignificant effort on the library author's part to change that to assert the true-minimum version of Go required, based on libraries and language features and su
Read the rest
ch. That's an effort most devs won't take on. I'd also guess that many developers, up-to this point if not indefinitely because education is hard, interpreted that `go` directive to mean more-of "the version of go this was built with"; not necessarily "the version of go minimally required". There are really major libraries (kubernetes/client-go [1]) which assert a minimum go version of 1.20; the latest version (see, for comparison, the aws-sdk, which specifies a more reasonable go1.11 [2]). I haven't, you know, fully audited these libraries, but 1.20 wasn't exactly a major release with huge language and library changes; do they really need 1.20? If devs haven't traditionally operated in this world where keeping this value super-current results in actually significant downstream costs in network bandwidth (go1.20 is 100mb!) and CI runtime, do we have confidence that the community will adapt? There's millions of Go packages out there. Or, will a future version of Go patch a security update, not backport it more than one version or so, and libraries have to specify the newest `go` directive version, because manifest security scanning and policy and whatever? Like, yeah, I get the rosy worldview of "your minimum version encodes required language and library features", but its not obvious to me that this is how this field is, or even will be, used. Just a LOT of tertiary costs to this change which I hope the team has thought through. [1] https://github.com/kubernetes/client-go/blob/master/go.mod#L... [2] https://github.com/aws/aws-sdk-go/blob/main/go.mod
In Go 1.21 will (probably) download newer toolchains on demand by default
That's a complicated question but allows highlighting what I was bringing up: the Key is any unicode character[1] so while it has become conventional to use "/", imagine if you wanted to store the output of exploded jar files in S3, but be able to "list the directory" of a jar's contents: `PutObject("/some-path/my.jar!/META-INF/MANIFEST.MF", "Manifest-Version: 1.0")` Now you can `ListObjects(Prefix="/some-path/my.jar", Delimiter="!")` to get the "interior files" back. I'm sure there are others, that's just one that I could think of off the top of my head. Mapping a URL and its interior resources would be another (`"https://example.com\t/script[1]", "console.log('hello, world')")` Further fun fact that even I didn't know until searching for other examples: "delimiter" is a string and thus can be `Delimiter=unknown` or such: https://github.
Read the rest
com/aws/aws-sdk-go/issues/2130 1: see the ListObject page under "encoding-type"
In Garage: An open-source distributed object storage service
Have a project that requires multiple versions of terraform? what? you don't want to... clone the terraform source repo ~ git remote -v origin https://github.com/hashicorp/terraform.git (fetch) origin https://github.com/hashicorp/terraform.git (push) check out the tag you want ~ git tag | tail -1 v1.1.5 ~ git checkout v1.1.5 Previous HEAD position was 516295951 Release v1.1.4 HEAD is now at fe2ddc22a Release v1.1.5 compile/install the binary in a local bin dirctory, ~ go build go: downloading github.com/aws/aws-sdk-go v1.42.35 ~ install terraform ~/bin/terraform-v1.1.5 ~ ls ~/bin/terraform\* /home/matt/bin/terraform /home/matt/bin/terraform-v0.13.7 /home/matt/bin/terraform-v1.1.4 /home/matt/bin/terraform-v0.13.4 /home/matt/bin/terraform-v0.14.9 /home/matt/bin/terraform-v1.1.5 then manage
Read the rest
a series of brittle aliases to disptach the proper version? ~ which terraform terraform () { binary=terraform if [[ $1 == "v"\* ]] && [[ $1 != "validate" ]] then version=$1 shift binary="$binary-$version" [ -f ~/bin/$binary ] || bail 1 "missing binary $binary" || return 1 else binary=/usr/bin/$binary fi dispatch --name terraform --scope --slice compilers.slice -c 35 -mh 2048M -mm 2048M -s 1M --binary $binary "$@" } (dispatch just runs things with memory and cpu limits) ~ which dispatch dispatch () { if [[ $USER == "root" ]] then command "$binary" "$@" return $? fi declare args=(--user --same-dir -p IOAccounting=yes -p MemoryAccounting=yes -p TasksAccounting=yes) while (($#)) do case "$1" in (-c) args+="-p" args+="CPUWeight=$2" shift 2 ;; (-mm) args+="-p" args+="MemoryMax=$2" shift 2 ;; (-mh) args+="-p" args+="MemoryHigh=$2" shift 2 ;; (-s) args+="-p" args+="MemorySwapMax=$2" shift 2 ;; (--scope) args+=--scope shift ;; (--slice) args+="--slice=$2" shift 2 ;; (--name) name=$1 shift 2 ;; (-P) args+=-P shift ;; (--binary) [ -z "$name" ] || name=$2 binary="$2" shift ;; (*) break ;; esac done systemd-run $args "$@" 2> >(>&2 grep -vE 'Running.*as unit:') } and of course, then you'd need a shitty little script to call your alias when other tools decide they want to call terraform ~ cat ~/bin/terraform #!/usr/bin/env zsh source ~/.zshrc >/dev/null 2>/dev/null || exit 1 terraform $@ Because that would be silly and dumb, and I totally don't do that for everything. Don't even get me started on virtualenvs.
In Asdf – language tool version manager
That said, as an operator of a number of fairly large kubernetes clusters (100-500 nodes), I might prefer java's memory tuneability to Go's garbage collector simply not caring about the max memory a system can offer. At scale, we need to heavily oversize the kubernetes masters to deal with the spikiness of go memory consumption. It's possible for a kube apiserver to average 2GB of memory use and then jump to 18GB after suddenly handling more requests than usual and get OOM-killed. I'd much rather it simply slow down a bit than behave so erratically. This is a common thing across all Go programs that handle data: since Go's garbage collector doesn't try to keep memory use within some upper bound, if you allocate and throw away a bunch of objects you'll quickly run out of memory on any low-memory system or container even though there's a to
Read the rest
n of memory ready to be reclaimed. Even a major library like the official AWS SDK's S3 client had this wrong as recently as 2017 (solution was to use sync.pool to avoid throwing away buffers): https://github.com/aws/aws-sdk-go/pull/1784 Python should perform much better from a memory perspective in these situations: its weakness would be the deserialized size that objects blow up to in memory, but its use would be bounded. Java would also handle this pretty effortlessly, though with a high enough rate of garbage production might hit a few short GC pauses that last far less time than a process restart. Really wish go were better about this. Imagine that a simple Go cronjob that uploads a backup to s3 at under a 160MB/sec could risk you OOM killing your server if you don't set cgroup memory caps on all your go processes.
In Million WebSockets and Go (2017)
I’m not a big fan of contrived examples with imaginary use cases, because they tend to fall short in actual use. > “Accept interfaces, return structs” Real example from personal (professional) life against that: Amazon AWS SDK defined S3 as a struct. That makes it bloody hard to mock during unit testing. I eventually ended up defining my own “s3iface” interface with corresponding mock to combat this, but now I have to repeat this for every program that uses it. Ok, I’ll separate it into its own package and include that everywhere. Wait, what was the point of the AWS SDK not doing this directly, again? Oh, look, they eventually ended up doing just that: providing an interface version of their S3 struct: https://godoc.org/github.com/aws/aws-sdk-go/service/s3/s3ifa... > Package s3iface provides an interface to enable mocking the Amazon Simpl
Read the rest
e Storage Service service client for testing your code. With the exact same name, to boot. Please consider providing and returning interfaces. Even if your struct is the only type implementing it.
In How to Use Go Interfaces
The original code was autogenerated, which is why the style was very terse and verbose. It's still like that: https://github.com/aws/aws-sdk-go/tree/master/models/apis The fact that it feels very Java-esque comes from two things, in my mind: - the AWS API has Java-esque RPC calls - the request/response paradigm is easier for code generation Personally, I don't like the style of the SDK, but at least it's maintained by AWS; you can always wrap the parts you use to get a nicer interface.
In The AWS SDK for Go is now 1.0
I've used the SDK in the past (before the 1.0). I am far from being a Go expert but you can see this has been written by Java developers. The usage is so verbose and you need to pass pointers around all the time. Even when it's clearly not changing the original instance (when passing by value would be enough). If you compare it to another lib like goamz you can clearly see how easier it is to use comparing to the Amazon SDK. There's also an issue from June 4 that discusses this: https://github.com/aws/aws-sdk-go/issues/265 In my lib I ended up going with goamz, it was much simpler to use and required much less boilerplate.
In The AWS SDK for Go is now 1.0

Showing the 15 most recent of 20 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.