Dear Racketeers,

I've recently been doing some work on Amazon Web Services and came
across Greg Hendershott's AWS package for Racket (thank you,
Greg!). This did nearly everything I'd wanted to do, modulo:

1. I didn't see an easy way to manually supply the
X-Amz-Security-Token when it's not obtained from an EC2 instance
metadata (e.g. obtained via STS's assume role or supplied as an
environment variable)

2. not all the AWS services I'd want to use are supported

In the end, I ended up using the Boto3 library and Python to do what I
needed for expediency, but it got me thinking about a more
comprehensive solution. I don't know that I have bandwidth to do this
myself at the moment, but I wanted to write up some of what I
discovered in hopes that it's useful / interesting to someone on this
list, or as a way of discovering that someone else is already working
on such an implementation :-)

What I discovered when I went looking for how 3rd parties have build
AWS SDK's what I learned is that many newer 3rd party SDKs are not
manually written. Instead they tend to use JSON specs provided by AWS
to automatically generate the SDK
(https://github.com/aws/aws-sdk-js/tree/master/apis). Examples of this
that may be of interest here include:

- Clojure's aws-api https://github.com/cognitect-labs/aws-api &
  https://www.youtube.com/watch?v=ppDtDP0Rntw

- Haskell's amazonka
  http://brendanhay.nz/amazonka-comprehensive-haskell-aws-client &
  https://github.com/brendanhay/amazonka

- Julia https://github.com/JuliaCloud/AWSSDK.jl

I'm told that this is how Amazon generates their SDKs as well as the
CLI interface for the AWS CLI. I was somewhat surprised to find that,
apart from Clojure, I couldn't find examples of this approach being
taken within the broader lisp community, given how well suited lisps
are for generating code from data.

One thing I discovered when looking through the Julia code that I
thought might be interesting to this group was that there is a macro
that creates, compiles, and deploys a Julia function to AWS Lambda,
allowing a kind of scalable parallel compute infrastructure:
https://github.com/samoconnor/AWSLambda.jl#run-a-julia-function-in-the-cloud. 
My
first thought was of some kind of remote places infrastructure for
Racket.

As I said, I probably don't have the bandwidth to tackle this myself,
but I thought that this approach might be interesting (maybe even
enticing) to members of this community. Thank you all for all the
great work you do!

Best,
Frank


-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/da86327a-7e1d-41c6-8e84-bc9cb19b4d22%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to