Y a-t-il des API pour les prix des services Web Amazon?
Y a-t-il des API qui ont des prix à jour sur les services Web Amazon? Quelque chose qui peut être interrogé, par exemple, pour le dernier prix S3 pour une région donnée ou EC2, etc.
merci
Mise à jour:
AWS a la tarification API de nos jours: https://aws.amazon.com/blogs/aws/new-aws-price-list-api/
Réponse originale:
C'est quelque chose que j'ai demandé (via des évangélistes et des enquêtes AWS) auparavant, mais n'a pas été à venir. Je suppose que les personnes AWS ont des innovations plus intéressantes à l'horizon.
Comme indiqué par @brokenbeatnik, il y a une API pour l'historique des prix sur place. API DOCS ICI: http://docs.amazonwserservices.com/awsec2/latest/apireence/apireference-query-descotesPotpricehistory.html
Je trouve étrange que l'historique des prix tache ait un officiel API, mais qu'ils ne l'ont pas fait pour des services à la demande en même temps. Quoi qu'il en soit, pour répondre à la question, Oui, vous pouvez interroger le annoncé Prix AWS ...
Le mieux que je puisse arriver vient d'examiner la source (côté client) des pages de tarification des différents services. Dans ce cas, vous constaterez que les tables sont construites dans JS et peuplées avec des données JSON, des données que vous pouvez obtenir vous-même. Par exemple.:
- http://aws.amazon.com/ec2/pricing/pricing-on-demand-Instances.json
- http://aws.amazon.com/s3/pring/pricing-storage.json
Ce n'est que la moitié de la bataille cependant, ensuite, vous devez éliminez le format d'objet pour obtenir aux valeurs que vous souhaitez, par exemple, dans Python cela obtient l'extra-large Hi-CPu Extra-Bread Linux Prix d'instance pour la Virginie:
>>> 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'
Clause de non-responsabilité: Évidemment, ce n'est pas une API sanctionnée API et, en tant que tel, je ne recommanderais pas d'attendre la stabilité du format de données ou même de continuer à existence de la source. Mais c'est là et il bat la transcription des données de tarification dans des fichiers de configuration/source statiques!
Pour les personnes qui souhaitaient utiliser les données de l'API Amazon qui utilise des choses comme "t1.micro" voici un tableau de traduction
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'
}
J'ai créé une API rapide et sale dans Python pour accéder aux données de tarification dans ces fichiers JSON et la convertir aux valeurs correspondantes (les bonnes traductions et les types d'instance de droite).
Vous pouvez obtenir le code ici: https://github.com/erans/ec2Istances
Et lisez un peu plus à ce sujet ici: http://forecastcloudy.net/2012/04/03/Quick-Dirty-api-for-accessing-aMazon-web-services-aws-ec2-mproprement-data /
Vous pouvez utiliser ce fichier comme module et appeler les fonctions pour obtenir un Python Dictionnaire avec les résultats, ou vous pouvez l'utiliser comme outil de ligne de commande pour que la sortie est une table lisible humaine, JSON ou CSV à utiliser en combinaison avec d'autres outils de ligne de commande.
Il y a une belle API disponible via le lien ci-dessous que vous pouvez interroger pour la tarification AWS.
Si vous jouez un peu avec les filtres, vous pouvez voir comment construire une requête pour renvoyer les informations spécifiques que vous êtes après ex. Région, type d'instance, etc. Par exemple, pour renvoyer un JSON contenant la tarification EC2 pour les instances UE-West-1 Region Linux, vous pouvez formater votre requête selon ci-dessous.
http://info.awstream.com/instances.json?region=eu-westoun-&os=Linux
Il suffit de remplacer JSON avec XML dans la requête ci-dessus pour renvoyer les informations dans un format XML.
Note - Semblable à l'URL affichée par d'autres contributeurs ci-dessus, je ne crois pas que ce soit une API AWS officiellement sanctionnée. Cependant, sur la base d'un certain nombre de contrôles sur place, j'ai fait au cours des deux derniers jours, je peux confirmer qu'au moment de publier les informations de tarification semble être correcte.
Pour ceux qui ont besoin des données de tarification complètes d'instance AWS (EC2, RDS, élastiche et redshift), voici le Python Module cultivé de celui suggéré ci-dessus par Sandler Eran :
https://github.com/ilia-semenov/awspricingfull
Il contient des instances de génération précédentes ainsi que des générations de courant (y compris la récente famille D2), des prix réservés et à la demande. Les formats JSON, Table et CSV sont disponibles.
J'ai aussi besoin d'une API pour récupérer des prix AWS. J'ai été surpris de ne rien trouver surtout compte tenu du grand nombre d'API disponibles pour les ressources AWS.
Ma langue préférée est Ruby Donc, j'ai donc écrit un joyau à appelé awscôts qui fournit un accès programmatique à la tarification AWS.
Voici un exemple de la recherche du prix à la demande d'une instance M1.Medium Linux.
Awscost.region ('US-East-1'). EC2.ON_DEMAND (: Linux) .price ('M1.Medium')
Je ne crois pas qu'il y ait une API qui couvre les prix actuels généraux des services standard. Cependant, pour EC2 en particulier, vous pouvez voir l'historique des prix sur place afin que vous n'ayez pas à deviner quel est le prix du marché d'une instance de point. Plus sur ceci est disponible à:
http://docs.amazonwebservices.com/awsec2/latest/developerguide/udule-spot-Instances-history.html
Un autre rapide et sale, mais avec une conversion à un format de données final plus pratique
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
J'ai fait un gist de noms avant et arrière à Yaml si quelqu'un en a besoin pour les rails, etc.
Voici une autre "API" non infiltrée qui couvre des instances réservées: http://aws.amazon.com/ec2/pring/pring/pring-Reserved-Instances.json
Il n'y a pas d'API de tarification, mais il y a un très bon prix mentionné ci-dessus. Dans l'ajout à la Ripper de prix EC2, je voudrais partager mes RDS et mes rippeuses elastiache:
https://github.com/evgeny-gridasov/rdsInstancesProlictionhttps://github.com/evgeny-gridasov/elastiCaRicing