¿Hay alguna API que tenga un precio actualizado en Amazon Web Services? Algo que se puede consultar, por ejemplo, para la última S3 precio de una región determinada, o EC2, etc.¿Hay alguna API para el PRECIO de los servicios web de Amazon?
gracias
No creo que hay una API que cubre los actuales precios generales de los servicios estándar . Sin embargo, para EC2 en particular, puede ver el historial de precios spot para que no tenga que adivinar cuál es el precio de mercado de una instancia puntual. Más sobre esto está disponible en:
http://docs.amazonwebservices.com/AWSEC2/latest/DeveloperGuide/using-spot-instances-history.html
No pude encontrar nada para el precio base, sin embargo, deltacloud es un proyecto muy interesante para la información entre nubes y administración http://deltacloud.org/ – edla
Tampoco vi una API general para los precios. Lo más parecido que encontré fue el historial de precios spot que describió brokenbeatnik. –
ACTUALIZACIÓN:
AWS tiene API de precios hoy en día: https://aws.amazon.com/blogs/aws/new-aws-price-list-api/
Respuesta original:
Esto es algo que he pedido para (a través de los evangelizadores y encuestas de AWS) anteriormente, pero no se ha recibido. Supongo que los amigos de AWS tienen innovaciones más interesantes en su horizonte.
Según lo señalado por @brokenbeatnik, hay una API para el historial de precios spot. documentación de la API aquí: http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeSpotPriceHistory.html
Me parece extraño que la historia precio spot tiene una API oficial, pero que no hacen esto por servicios a la carta, al mismo tiempo. De todos modos, al responder a la pregunta, sí se puede consultar la anunciada AWS precios ...
Lo mejor que puedo llegar a es de examinar la (del lado del cliente) fuente de las páginas de precios de los diferentes servicios . Allí encontrará que las tablas están compiladas en JS y pobladas con datos JSON, datos que puede OBTENER usted mismo. Por ejemplo:
eso es sólo la mitad de la batalla, sin embargo, al lado hay que desmenuzar el formato de objeto para llegar a los valores que desee, por ejemplo, en Python ahora se pone la hi-CPU On-Demand de precios extra grande de Linux Instancia de 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'
responsabilidad: Obviamente, esto no es una API AWS y sancionada como tal no recomendaría esperar la estabilidad del formato de datos o incluso la existencia continuada de la fuente. ¡Pero está ahí, y es mejor transcribir los datos de fijación de precios en archivos estáticos de configuración/fuente!
También vale la pena señalar una advertencia al leer el historial de precios spot de la API; solo mostrará los cambios entre la hora de inicio y finalización. Algunos tipos de instancias no son compatibles en ciertas zonas de disponibilidad (y detectar esto es bastante difícil ya que si solicita las últimas 24 horas de precios spot, un precio sin cambios se vería como un tipo de instancia no soportada en esa región (o viceversa) – Peter
Tenga en cuenta que a partir de abril de 2014, esas URL están en desuso y la información de precios está desactualizada. Ahora están en http://a0.awsstatic.com/pricing/1/ec2/linux-od.min.js y en http://a0.awsstatic.com/pricing/1/s3/pricing-storage-s3.min.js. Si busca en el origen de cualquier página de precios y busca "json", encontrará los enlaces apropiados. –
@TimDorr ¿Puedes editar la publicación o publicar tu respuesta si lo anterior ya está desactualizado? – CMCDragonkai
Para las personas que querían utilizar los datos de la API de Amazon que usa cosas como "t1.micro" aquí es una matriz traducción
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'
}
he crear una rápida & API sucia en Python para acceder a los datos de precios en esos archivos JSON y convertirlos a los valores relevantes (las traducciones correctas y los tipos correctos de instancias).
Puede obtener el código aquí: https://github.com/erans/ec2instancespricing
y leer un poco más sobre él aquí: http://forecastcloudy.net/2012/04/03/quick-dirty-api-for-accessing-amazon-web-services-aws-ec2-pricing-data/
Puede utilizar este archivo como un módulo y llamar a las funciones para obtener un diccionario de Python con los resultados , o puede usarlo como una herramienta de línea de comando para obtener el resultado es una tabla legible por humanos, JSON o CSV para usar en combinación con otras herramientas de línea de comando.
Muy bien, pero noté que no incluye las instancias de generación anterior como t1.micro - ¿hay otro archivo .js que contenga esos precios ? –
hice un Gist de avance y retroceso nombres en Yaml si alguien los necesita para rieles, etc.
Otra rápida & sucia, pero con una conversión a un formato de datos final más conveniente
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
Aquí hay otra "API" no autorizada que cubre instancias reservadas: http://aws.amazon.com/ec2/pricing/pricing-reserved-instances.json
Yo también necesitaba una API para recuperar los precios de AWS. Me sorprendió no encontrar nada especialmente dado el gran número de API disponibles para los recursos de AWS.
Mi idioma preferido es Ruby, así que escribí una gema llamada AWSCosts que proporciona acceso programático a los precios de AWS.
Aquí hay un ejemplo de cómo encontrar el precio bajo demanda para una instancia de Linux m1.medium.
AWSCosts.region ('nosotros-este-1') ec2.on_demand. (Linux) .price ('m1.medium')
No hay API de fijación de precios, pero hay muy buen precio mencionado anteriormente. En la adición al extractor de precio EC2 me gustaría compartir mis RDS y desgarradores de precios ElastiCache:
https://github.com/evgeny-gridasov/rdsinstancespricing https://github.com/evgeny-gridasov/elasticachepricing
Hay una reply to a similar question que enumera todos los archivos que contienen .js los precios, que son apenas Archivos JSON (con solo una declaración callback(...); para eliminar).
Aquí es un exemple para Linux en los precios de la demanda: http://aws-assets-pricing-prod.s3.amazonaws.com/pricing/ec2/linux-od.js
(Obtener la lista completa directly on that reply)
Hay una bonita API disponible a través del enlace debajo de la cual se puede consultar para obtener precios de AWS.
Si juegas un poco con los filtros, se puede ver cómo construir una consulta para devolver la información específica que está después de, por ejemplo, región, tipo de instancia, etc. Por ejemplo, para devolver un json que contenga el precio de EC2 para las instancias linux de la región eu-west-1, puede formatear su consulta como se indica a continuación.
http://info.awsstream.com/instances.json?region=eu-west-1&os=linux
Basta con sustituir JSON con XML en la consulta anterior para devolver la información en un formato XML.
Nota: similar a la URL publicada por otros colaboradores anteriores, no creo que esta sea una API de AWS oficialmente sancionada. Sin embargo, de acuerdo con una serie de comprobaciones puntuales que hice en los últimos días, puedo confirmar que al momento de publicar la información de precios parece ser correcta.
Para aquellos que necesitan los datos de precios instancia AWS integrales (EC2, RDS, ElastiCache y Redshift), aquí está el módulo de Python crecido de la sugerida anteriormente por Eran Sandler:
https://github.com/ilia-semenov/awspricingfull
Contiene anterior instancias de generación así como las de generación actual (incluida la familia d2 más reciente), precios reservados y bajo demanda. Están disponibles los formatos JSON, Table y CSV.
http://stackoverflow.com/questions/7334035/get-ec2-pricing-programmatically – auselen
AWS tiene una lista de precios API ahora https://aws.amazon.com/blogs/aws/new-aws-price- list-api/ –
Utilice el CLI ... ejemplo: 'aws ec2 describe-spot-price-history --instance-types m1.xlarge --product-description" Linux/UNIX (Amazon VPC) "--start-time 2016-10-31T03: 00: 00 - hora del final 2016-10-31T03: 16: 00 --query 'SpotPriceHistory [*]. [Timestamp, SpotPrice]' 'vea los [documentos] (http: // docs .aws.amazon.com/cli/latest/reference/ec2/describe-spot-price-history.html) –