Esistono API con prezzi aggiornati su Amazon Web Services? Qualcosa che può essere interrogato, ad esempio, per l'ultimo S3 prezzo per una data regione, o EC2, eccEsistono API per i prezzi dei servizi Web Amazon?
grazie
Non credo ci sia un'API che copre prezzi correnti generali per i servizi standard . Tuttavia, per EC2 in particolare, è possibile visualizzare la cronologia dei prezzi spot in modo da non dover indovinare quale sia il prezzo di mercato per un'istanza spot. Maggiori informazioni su questo è disponibile all'indirizzo:
http://docs.amazonwebservices.com/AWSEC2/latest/DeveloperGuide/using-spot-instances-history.html
non sono riuscito a trovare nulla per i prezzi di base, tuttavia deltacloud è un progetto molto interessante per le informazioni cross-cloud e gestione http://deltacloud.org/ – edla
Inoltre non ho visto un'API generale per i prezzi. Il più vicino che ho trovato è stata la cronologia dei prezzi spot descritta da brokenbeatnik. –
UPDATE:
AWS ha API prezzi al giorno d'oggi: https://aws.amazon.com/blogs/aws/new-aws-price-list-api/
risposta originale:
Questo è qualcosa che ho chiesto per (tramite evangelisti e sondaggi AWS) in precedenza, ma non è stato imminente. Immagino che le persone di AWS abbiano al loro orizzonte innovazioni più interessanti.
Come indicato da @brokenbeatnik, esiste un'API per la cronologia dei prezzi spot. docs API qui: http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeSpotPriceHistory.html
Trovo strano che la storia spot-prezzo ha un funzionario API , ma che non hanno fatto questo per servizi on-demand allo stesso tempo. In ogni caso, per rispondere alla domanda, sì, si può interrogare il pubblicizzato AWS prezzi ...
Il meglio che posso venire in mente è di esaminare il (lato client) sorgente delle pagine di prezzo dei vari servizi . Qui troverai che le tabelle sono costruite in JS e popolate con dati JSON, dati che puoi ottenere da te. Ad esempio:
Questo è solo metà della battaglia, però, la prossima si deve scegliere a parte il formato oggetto per arrivare ai valori che si desidera, ad esempio, in Python questo diventa il Hi-CPU on-demand prezzi Extra-Large Linux grado per Virginia:
>>> import json
>>> import urllib2
>>> response = urllib2.urlopen('http://aws.amazon.com/ec2/pricing/pricing-on-demand-instances.json')
>>> pricejson = response.read()
>>> pricing = json.loads(pricejson)
>>> pricing['config']['regions'][0]['instanceTypes'][3]['sizes'][1]['valueColumns'][0]['prices']['USD']
u'0.68'
Disclaimer: Ovviamente questo non è un sanzionato API AWS e come non consiglierei di prevedere la stabilità del formato dei dati o persino l'esistenza continua della fonte. Ma è lì, e batte trascrivere i dati dei prezzi in file config/sorgenti statici!
Vale anche la pena di notare un avvertimento con la lettura della cronologia dei prezzi spot dell'API: mostrerà solo le modifiche tra l'ora di inizio e quella di fine. Alcuni tipi di istanza non sono supportati in determinate zone di disponibilità (e rilevare questo è piuttosto difficile poiché se si chiedono le ultime 24 ore di dati sui prezzi spot un prezzo immutato sembrerebbe un tipo di istanza non supportato in quella regione (o viceversa) – Peter
Da aprile 2014, tali URL sono obsoleti e le informazioni sui prezzi non sono aggiornate. Sono ora disponibili all'indirizzo http://a0.awsstatic.com/pricing/1/ec2/linux-od.min.js e http://a0.awsstatic.com/pricing/1/s3/pricing-storage-s3.min.js Se cerchi la fonte di qualsiasi pagina di prezzo e cerchi "json" troverai i link appropriati –
@TimDorr puoi modificare il post o postare la tua risposta se quanto sopra è obsoleto? – CMCDragonkai
Per le persone che volevano usare i dati dalle API di Amazon che usa le cose come "t1.micro" qui è un array di traduzione
type_translation = {
'm1.small' : ['stdODI', 'sm'],
'm1.medium' : ['stdODI', 'med'],
'm1.large' : ['stdODI', 'lg'],
'm1.xlarge' : ['stdODI', 'xl'],
't1.micro' : ['uODI', 'u'],
'm2.xlarge' : ['hiMemODI', 'xl'],
'm2.2xlarge' : ['hiMemODI', 'xxl'],
'm2.4xlarge' : ['hiMemODI', 'xxxxl'],
'c1.medium' : ['hiCPUODI', 'med'],
'c1.xlarge' : ['hiCPUODI', 'xl'],
'cc1.4xlarge' : ['clusterComputeI', 'xxxxl'],
'cc2.8xlarge' : ['clusterComputeI', 'xxxxxxxxl'],
'cg1.4xlarge' : ['clusterGPUI', 'xxxxl'],
'hi1.4xlarge' : ['hiIoODI', 'xxxx1']
}
region_translation = {
'us-east-1' : 'us-east',
'us-west-2' : 'us-west-2',
'us-west-1' : 'us-west',
'eu-west-1' : 'eu-ireland',
'ap-southeast-1' : 'apac-sin',
'ap-northeast-1' : 'apac-tokyo',
'sa-east-1' : 'sa-east-1'
}
ho creare un rapido & API sporco in Python per accedere ai dati di prezzo in quei file JSON e convertirli nei valori rilevanti (le giuste traduzioni e i giusti tipi di istanze).
È possibile ottenere il codice qui: https://github.com/erans/ec2instancespricing
e leggere un po 'più su di esso qui: http://forecastcloudy.net/2012/04/03/quick-dirty-api-for-accessing-amazon-web-services-aws-ec2-pricing-data/
È possibile utilizzare questo file come un modulo e chiamare le funzioni per ottenere un dizionario Python con i risultati oppure puoi usarlo come strumento da riga di comando per ottenere che l'output sia una tabella leggibile dall'uomo, JSON o CSV da usare in combinazione con altri strumenti da riga di comando.
Molto bello, ma ho notato che non include le istanze di generazione precedente come t1.micro - c'è un altro file .js che contiene quelli prezzi ? –
ho fatto un Gist avanti e di nomi in YAML invertire qualcuno dovrebbe bisogno di loro per Rails, ecc
Un'altra rapida & sporca, ma con una conversione ad un più comodo formato di dati finale
class CostsAmazon(object):
'''Class for general info on the Amazon EC2 compute cloud.
'''
def __init__(self):
'''Fetch a bunch of instance cost data from Amazon and convert it
into the following form (as self.table):
table['us-east']['linux']['m1']['small']['light']['ondemand']['USD']
'''
#
# tables_raw['ondemand']['config']['regions'
# ][0]['instanceTypes'][0]['sizes'][0]['valueColumns'][0
# ]['prices']['USD']
#
# structure of tables_raw:
# ┃
# ┗━━[key]
# ┣━━['use'] # an input 3 x ∈ { 'light', 'medium', ... }
# ┣━━['os'] # an input 2 x ∈ { 'linux', 'mswin' }
# ┣━━['scheduling'] # an input
# ┣━━['uri'] # an input (see dict above)
# ┃ # the core output from Amazon follows
# ┣━━['vers'] == 0.01
# ┗━━['config']:
# * ┣━━['regions']: 7 x
# ┃ ┣━━['region'] == ∈ { 'us-east', ... }
# * ┃ ┗━━['instanceTypes']: 7 x
# ┃ ┣━━['type']: 'stdODI'
# * ┃ ┗━━['sizes']: 4 x
# ┃ ┗━━['valueColumns']
# ┃ ┣━━['size']: 'sm'
# * ┃ ┗━━['valueColumns']: 2 x
# ┃ ┣━━['name']: ~ 'linux'
# ┃ ┗━━['prices']
# ┃ ┗━━['USD']: ~ '0.080'
# ┣━━['rate']: ~ 'perhr'
# ┣━━['currencies']: ∈ { 'USD', ... }
# ┗━━['valueColumns']: [ 'linux', 'mswin' ]
#
# The valueColumns thing is weird, it looks like they're trying
# to constrain actual data to leaf nodes only, which is a little
# bit of a conceit since they have lists in several levels. So
# we can obtain the *much* more readable:
#
# tables['regions']['us-east']['m1']['linux']['ondemand'
# ]['small']['light']['USD']
#
# structure of the reworked tables:
# ┃
# ┗━━[<region>]: 7 x ∈ { 'us-east', ... }
# ┗━━[<os>]: 2 x ∈ { 'linux', 'mswin' } # oses
# ┗━━[<type>]: 7 x ∈ { 'm1', ... }
# ┗━━[<scheduling>]: 2 x ∈ { 'ondemand', 'reserved' }
# ┗━━[<size>]: 4 x ∈ { 'small', ... }
# ┗━━[<use>]: 3 x ∈ { 'light', 'medium', ... }
# ┗━━[<currency>]: ∈ { 'USD', ... }
# ┗━━> ~ '0.080' or None
uri_base = 'http://aws.amazon.com/ec2/pricing'
tables_raw = {
'ondemand': {'scheduling': 'ondemand',
'uri': '/pricing-on-demand-instances.json',
'os': 'linux', 'use': 'light'},
'reserved-light-linux': {
'scheduling': 'ondemand',
'uri': 'ri-light-linux.json', 'os': 'linux', 'use': 'light'},
'reserved-light-mswin': {
'scheduling': 'ondemand',
'uri': 'ri-light-mswin.json', 'os': 'mswin', 'use': 'light'},
'reserved-medium-linux': {
'scheduling': 'ondemand',
'uri': 'ri-medium-linux.json', 'os': 'linux', 'use': 'medium'},
'reserved-medium-mswin': {
'scheduling': 'ondemand',
'uri': 'ri-medium-mswin.json', 'os': 'mswin', 'use': 'medium'},
'reserved-heavy-linux': {
'scheduling': 'ondemand',
'uri': 'ri-heavy-linux.json', 'os': 'linux', 'use': 'heavy'},
'reserved-heavy-mswin': {
'scheduling': 'ondemand',
'uri': 'ri-heavy-mswin.json', 'os': 'mswin', 'use': 'heavy'},
}
for key in tables_raw:
# expand to full URIs
tables_raw[key]['uri'] = (
'%s/%s'% (uri_base, tables_raw[key]['uri']))
# fetch the data from Amazon
link = urllib2.urlopen(tables_raw[key]['uri'])
# adds keys: 'vers' 'config'
tables_raw[key].update(json.loads(link.read()))
link.close()
# canonicalize the types - the default is pretty annoying.
#
self.currencies = set()
self.regions = set()
self.types = set()
self.intervals = set()
self.oses = set()
self.sizes = set()
self.schedulings = set()
self.uses = set()
self.footnotes = {}
self.typesizes = {} # self.typesizes['m1.small'] = [<region>...]
self.table = {}
# grovel through Amazon's tables_raw and convert to something orderly:
for key in tables_raw:
scheduling = tables_raw[key]['scheduling']
self.schedulings.update([scheduling])
use = tables_raw[key]['use']
self.uses.update([use])
os = tables_raw[key]['os']
self.oses.update([os])
config_data = tables_raw[key]['config']
self.currencies.update(config_data['currencies'])
for region_data in config_data['regions']:
region = self.instance_region_from_raw(region_data['region'])
self.regions.update([region])
if 'footnotes' in region_data:
self.footnotes[region] = region_data['footnotes']
for instance_type_data in region_data['instanceTypes']:
instance_type = self.instance_types_from_raw(
instance_type_data['type'])
self.types.update([instance_type])
for size_data in instance_type_data['sizes']:
size = self.instance_size_from_raw(size_data['size'])
typesize = '%s.%s' % (instance_type, size)
if typesize not in self.typesizes:
self.typesizes[typesize] = set()
self.typesizes[typesize].update([region])
self.sizes.update([size])
for size_values in size_data['valueColumns']:
interval = size_values['name']
self.intervals.update([interval])
for currency in size_values['prices']:
cost = size_values['prices'][currency]
self.table_add_row(region, os, instance_type,
size, use, scheduling,
currency, cost)
def table_add_row(self, region, os, instance_type, size, use, scheduling,
currency, cost):
if cost == 'N/A*':
return
table = self.table
for key in [region, os, instance_type, size, use, scheduling]:
if key not in table:
table[key] = {}
table = table[key]
table[currency] = cost
def instance_region_from_raw(self, raw_region):
'''Return a less intelligent given EC2 pricing name to the
corresponding region name.
'''
regions = {
'apac-tokyo' : 'ap-northeast-1',
'apac-sin' : 'ap-southeast-1',
'eu-ireland' : 'eu-west-1',
'sa-east-1' : 'sa-east-1',
'us-east' : 'us-east-1',
'us-west' : 'us-west-1',
'us-west-2' : 'us-west-2',
}
return regions[raw_region] if raw_region in regions else raw_region
def instance_types_from_raw(self, raw_type):
types = {
# ondemand reserved
'stdODI' : 'm1', 'stdResI' : 'm1',
'uODI' : 't1', 'uResI' : 't1',
'hiMemODI' : 'm2', 'hiMemResI' : 'm2',
'hiCPUODI' : 'c1', 'hiCPUResI' : 'c1',
'clusterComputeI' : 'cc1', 'clusterCompResI' : 'cc1',
'clusterGPUI' : 'cc2', 'clusterGPUResI' : 'cc2',
'hiIoODI' : 'hi1', 'hiIoResI' : 'hi1'
}
return types[raw_type]
def instance_size_from_raw(self, raw_size):
sizes = {
'u' : 'micro',
'sm' : 'small',
'med' : 'medium',
'lg' : 'large',
'xl' : 'xlarge',
'xxl' : '2xlarge',
'xxxxl' : '4xlarge',
'xxxxxxxxl' : '8xlarge'
}
return sizes[raw_size]
def cost(self, region, os, instance_type, size, use, scheduling,
currency):
try:
return self.table[region][os][instance_type][
size][use][scheduling][currency]
except KeyError as ex:
return None
Ecco un'altra "API" non autorizzata che copre istanze riservate: http://aws.amazon.com/ec2/pricing/pricing-reserved-instances.json
Anch'io avevo bisogno di un'API per recuperare i prezzi di AWS. Sono stato sorpreso di non trovare nulla in particolare dato il gran numero di API disponibili per le risorse AWS.
La mia lingua preferita è Ruby, quindi ho scritto una gemma chiamata AWSCosts che fornisce accesso programmatico ai prezzi di AWS.
Ecco un esempio di come trovare il prezzo su richiesta per un'istanza di m1.medium Linux.
AWSCosts.region ('noi-est-1') ec2.on_demand. (: Linux) .price ('m1.medium')
Non c'è api prezzi, ma ci sono prezzo molto bello di cui sopra. In aggiunta al prezzo ripper EC2 mi piacerebbe condividere le mie RDS e ripper prezzo elasticache:
https://github.com/evgeny-gridasov/rdsinstancespricing https://github.com/evgeny-gridasov/elasticachepricing
C'è una reply to a similar question che elenca tutti i file .js contenenti i prezzi, che sono a malapena File JSON (con solo una dichiarazione callback(...); da rimuovere).
Ecco un exemple per Linux Sui prezzi richiesta: http://aws-assets-pricing-prod.s3.amazonaws.com/pricing/ec2/linux-od.js
(Prendi l'elenco completo directly on that reply)
C'è una bella API disponibile tramite il link di sotto del quale è possibile interrogare per i prezzi AWS.
Se si gioca un po 'con i filtri, si può vedere come costruire una query per restituire le informazioni specifiche che sono dopo per esempio regione, tipo di istanza, ecc. Ad esempio, per restituire un json contenente il prezzo EC2 per le istanze di linux della regione eu-west-1, è possibile formattare la query come di seguito.
http://info.awsstream.com/instances.json?region=eu-west-1&os=linux
Basta sostituire JSON con XML nella query precedente per restituire le informazioni in un formato XML.
Nota: analogamente agli URL pubblicati da altri contributori sopra, non credo che questa sia un'API AWS ufficialmente approvata. Tuttavia, in base a una serie di controlli a campione effettuati negli ultimi due giorni, posso confermare che al momento della pubblicazione le informazioni sui prezzi sembrano corrette.
Per chi ha bisogno dei dati dei prezzi esempio completi AWS (EC2, RDS, ElastiCache e Redshift), qui è il modulo Python cresciuto da quello suggerito sopra da Eran Sandler:
https://github.com/ilia-semenov/awspricingfull
Contiene precedente istanze di generazione e generazione attuale (compresa la nuova famiglia d2), prezzi riservati e su richiesta. Formati JSON, Table e CSV disponibili.
http://stackoverflow.com/questions/7334035/get-ec2-pricing-programmatically – auselen
AWS ha ora un listino prezzi API https://aws.amazon.com/blogs/aws/new-aws-price- list-api/ –
Utilizzare l'esempio CLI ... 'aws ec2 Descrive-spot-price-history -instance-types m1.xlarge --product-description" Linux/UNIX (Amazon VPC) "--start-time 2016-10-31T03: 00: 00 - end-time 2016-10-31T03: 16: 00 - query 'SpotPriceHistory [*]. [Timestamp, SpotPrice]' 'vedi i [documenti] (http: // docs .aws.amazon.com/cli/latest/reference/ec2/describe-spot-price-history.html) –