spotprice | Quickly get AWS spot instance pricing | AWS library

Quite sure this is not the most 'clean' solution, but thought I'd share it until there's a better approach

Idea:

1. group_by each InstanceType
2. map each SpotPrice, add those values by using add, devide by map length to get avarage (map(.SpotPrice | tonumber) | add / length)

I think that it can take some time for a Spot Instance request to be fulfilled.

I would recommend you call describe_spot_instance_requests() until the Status of all instances is fulfilled (wait a little bit between each call).

I can't see a field that indicates that the whole request has been fulfilled, so you might need to compare the number of instances returned against the quantity that you requested.

will those additional methods put additional strain on the system memory or are they "shared" between all structs of type PriceElement?

Code is shared between all instances. So no additional memory will be used.

Code is stored separately from any data, and the memory for the code is only dependent on the amount of code, not how many instance of objects there are. This is true for both classes and structs. The main exception is generics, this will create a copy of the code for each type combination that is used. It is a bit more complicated since the code is Jitted, cached etc, but that is irrelevant in most cases since you cannot control it anyway.

I would recommend making your struct immutable. I.e. change UpdatePrice so it returns a new struct instead of changing the existing one. See why is mutable structs evil for details. Making the struct immutable allow you to mark the struct as readonly and that can help avoid copies when passing the struct with an in parameter. In modern c# you can take references to structs in an array, and that also helps avoiding copies (as you seem to be aware of).

Have a look at read very carefully https://docs.julialang.org/en/v1/manual/performance-tips/

Basic cleanups start with:

1. Your SpotPrices struct does not need to me mutable. Anyway since there is only one field you could just define it as SpotPrices=Vector{Float64}
2. You do not want untyped containers - instead of prices = [] do prices = Float64[]
3. Using DataFrames.groupby will be much faster than finding unique elements and filtering by them
4. If yo do not need initialze than do not do it Vector{Float64}(undef, sample_size) is much faster than zeros(sample_size, 24)
5. You do not need to synchronize @sync before a multi-threaded loop
6. Create a random states - one separate one for each thread and use them whenever calling the rand function

The error message is correct. According to the documentation, the RequestSpotLaunchSpecification object doesn't have an attribute called TagSpecifications.

However, you can tag your Spot Instance request after you create it.

ec2.requestSpotInstances(params) returns an array of SpotInstanceRequest objects, each containing a spotInstanceRequestId (e.g. sir-012345678). Use the CreateTags API with these Spot Instance request ids to add the tags.

There's no such thing called EMR spot pricing, as already mentioned in the comment. Spot pricing is for EC2 instances. You can look at this AWS spot advisor page to find out which instance categories have lower interruption rate, and choose based on that.

Since 2017, AWS has changed the algorithm for spot pricing, "where prices adjust more gradually, based on longer-term trends in supply and demand", so you probably don't need to look at the historical spot prices. More details about that can be found here.

Nowadays, you're most likely gonna be fine using the last price (+ delta) for that instance. This can be achieved using the following code snippet:

Update:

After checking the documentation it seems like you have to specify an array of GroupIdentifier:

Check documentation on AWS::EC2::SpotFleet. It only supports SpotFleetRequestConfigData as property.

You will probably need to specify something like:

Both represent a json array containing jsonObjects of same structure. Displaying result will depend on your front implementation not the layaout of your jsonRespense.