Download - AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

Transcript
Page 1: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar RubyDeveloper Guide

AWS SDK parar Ruby: Developer GuideCopyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Page 2: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer Guide

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.

Page 3: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer Guide

Table of ContentsAWS SDK for Ruby Developer Guide ................................................................................................... 1

Acerca de esta guía ................................................................................................................... 1Documentación y recursos adicionales .......................................................................................... 1

Implementación en la nube de AWS ...................................................................................... 2Introducción a AWS SDK for Ruby ....................................................................................................... 3

Guía de inicio rápido de AWS SDK for Ruby ................................................................................. 3Escribir el código ................................................................................................................ 3Ejecutar el código ............................................................................................................... 3Nota para usuarios de Windows ........................................................................................... 3

Instalación de AWS SDK for Ruby ............................................................................................... 4Requisitos previos .............................................................................................................. 4Instalación de AWS SDK for Ruby ........................................................................................ 4

Configuración de AWS SDK for Ruby ........................................................................................... 5Configuración de las credenciales de AWS ............................................................................ 5Creación de un token de acceso de AWS STS ....................................................................... 6Configuración de una región ................................................................................................ 7Configuración de un punto de enlace no estándar ................................................................... 7

Uso de AWS SDK for Ruby REPL ............................................................................................... 8Uso del SDK con Ruby on Rails .................................................................................................. 8

Integración de AWS SDK for Ruby con Rails .......................................................................... 8Soporte de Amazon SES para ActionMailer ............................................................................ 8Registro ............................................................................................................................ 9

Migración de la versión 1 a la versión 2 de AWS SDK for Ruby ......................................................... 9Uso en paralelo .................................................................................................................. 9Diferencias generales .......................................................................................................... 9Diferencias del cliente ....................................................................................................... 10Diferencias en los recursos ................................................................................................ 10

Tutorial Hello World ......................................................................................................................... 12Uso de AWS SDK for Ruby en el programa .................................................................................. 12Creación de un recurso de Amazon S3 ........................................................................................ 12Creación de un bucket .............................................................................................................. 12Añadir un archivo al bucket ........................................................................................................ 12Mostrar el contenido de un bucket .............................................................................................. 12Programa completo ................................................................................................................... 13Ejecución del programa ............................................................................................................. 14Pasos siguientes ....................................................................................................................... 15

Programación con AWS SDK for Ruby ............................................................................................... 16Consejo de depuración: Obtener información del rastro de red de un cliente ...................................... 16Stub: respuestas y errores de cliente .......................................................................................... 17

Stub: respuestas de cliente ................................................................................................ 17Stub: errores de cliente ..................................................................................................... 18

Paginación de los datos de respuesta ........................................................................................ 18Las respuestas paginadas se pueden enumerar .................................................................... 18Administrar respuestas paginadas manualmente .................................................................... 19Clases de datos paginados ................................................................................................ 19

Uso de esperadores ................................................................................................................. 19Llamada a un esperador .................................................................................................... 19Errores de espera ............................................................................................................. 20Configuración de un esperador ........................................................................................... 20Ampliación de un esperador ............................................................................................... 20

Especificación de la duración del tiempo de espera de un cliente .................................................... 21Ejemplos de código de AWS SDK for Ruby ......................................................................................... 22

Ejemplos de Amazon CloudWatch .............................................................................................. 22Obtener información acerca de todas las alarmas ................................................................. 22

iii

Page 4: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer Guide

Creación de una alarma ................................................................................................... 23Habilitación y deshabilitación de las acciones de alarma ........................................................ 24Obtener información sobre métricas personalizadas .............................................................. 25Envío de eventos a Amazon CloudWatch Events .................................................................. 26

Ejemplos de Amazon DynamoDB ............................................................................................... 29Obtener información acerca de todas las tablas ................................................................... 30Creación de una tabla simple con una única clave principal .................................................... 30Añadir un elemento a una tabla ......................................................................................... 31Obtener información sobre los elementos de una tabla .......................................................... 31Obtener información acerca de un elemento específico de una tabla ........................................ 31Actualización de una tabla ................................................................................................ 32Creación de un índice ...................................................................................................... 32

Ejemplos de Amazon EC2 ........................................................................................................ 33Creación de una VPC ...................................................................................................... 34Creación de una gateway de Internet y su asociación a una VPC ............................................ 34Crear una subred pública .................................................................................................. 34Creación de una tabla de ruteo y su asociación a una subred ................................................. 35Uso de direcciones IP elásticas en Amazon EC2 .................................................................. 35Creación de un grupo de seguridad .................................................................................... 37Trabajar con grupos de seguridad en Amazon EC2 .............................................................. 37Trabajar con pares de claves ............................................................................................ 40Obtener información acerca de todas las instancias .............................................................. 43Obtener información acerca de todas las instancias con un valor de etiqueta específico ............... 43Obtener información acerca de una instancia específica ........................................................ 44Creación de una instancia ................................................................................................. 44Parada de una instancia ................................................................................................... 45Iniciar una instancia ......................................................................................................... 45Reinicio de una instancia .................................................................................................. 45Administración de instancias Amazon EC2 en Amazon EC2 ................................................... 46Terminación de una instancia ............................................................................................ 47Obtener información sobre las regiones y las zonas de disponibilidad ...................................... 48

Ejemplos de AWS Elastic Beanstalk ........................................................................................... 50Obtener información acerca de todas las aplicaciones ........................................................... 50Obtener información acerca de una aplicación específica ....................................................... 50Actualización de una aplicación Ruby on Rails ..................................................................... 51

Ejemplos de AWS Identity and Access Management ..................................................................... 52Obtener información sobre todos los usuarios ...................................................................... 52Añadir un usuario nuevo ................................................................................................... 53Creación de las claves de acceso de un usuario .................................................................. 53Agregar una política administrada ...................................................................................... 54Creación de un rol ........................................................................................................... 54Administración de usuarios de IAM ..................................................................................... 55Trabajar con políticas de IAM ............................................................................................ 56Administración de las claves de acceso de IAM ................................................................... 57Uso de certificados de servidor de IAM ............................................................................... 59Administración de alias de cuenta de IAM ........................................................................... 60

Ejemplos de Lambda ............................................................................................................... 61Visualización de información acerca de todas las funciones de Lambda ..................................... 61Creación de una función de Lambda ................................................................................... 62Ejecución de una función de Lambda .................................................................................. 62Configuración de una función de Lambda para recibir notificaciones ......................................... 64

Ejemplos de Amazon Relational Database Service ....................................................................... 64Obtener información acerca de todas las instancias .............................................................. 65Obtener información acerca de todas las instantáneas .......................................................... 65Obtener información sobre todos los clústeres y sus instantáneas ........................................... 65Obtener información acerca de todos los grupos de seguridad ................................................ 66Obtener información acerca de todos los grupos de subred .................................................... 66

iv

Page 5: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer Guide

Obtener información acerca de todos los grupos de parámetros .............................................. 67Creación de instantáneas a partir de instancias .................................................................... 67Crear una instantánea de un clúster ................................................................................... 67

Ejemplos de Amazon S3 ............................................................................................................ 68Obtener información acerca de todos los buckets ................................................................. 68Obtener información acerca de todos los buckets de una región .............................................. 69Creación y uso de un bucket de Amazon S3 ....................................................................... 69Determinar si existe un bucket ........................................................................................... 73Obtener información sobre elementos de buckets ................................................................. 73Carga de un elemento en un bucket ................................................................................... 74Carga de un elemento con metadatos en un bucket .............................................................. 74Descargar un objeto de un bucket en un archivo .................................................................. 74Cambio de las propiedades de un elemento del bucket ......................................................... 75Activación de una notificación cuando se adjunta un elemento a un bucket ............................... 75Creación de una plantilla de configuración de reglas de ciclo de vida para un bucket ................... 77Creación de una política de buckets con Ruby ..................................................................... 79Configuración de buckets para uso compartido de recursos entre orígenes (CORS) .................... 82Administración de permisos de acceso a objetos y buckets de Amazon S3 ................................ 85Uso de un bucket de Amazon S3 para alojar un sitio web ...................................................... 88

Ejemplos de Amazon SNS ......................................................................................................... 91Obtener información sobre todos los temas ......................................................................... 92Creación de un tema ....................................................................................................... 92Obtener información acerca de todas las suscripciones de un tema ......................................... 92Creación de una suscripción en un tema ............................................................................. 92Envío de un mensaje a todos los suscriptores del tema ......................................................... 93Habilitación de un recurso para publicarlo en un tema ........................................................... 93

Ejemplos de Amazon SQS ......................................................................................................... 94Obtener información acerca de todas las colas en Amazon SQS ............................................. 94Creación de una cola en Amazon SQS ............................................................................... 95Uso de colas en Amazon SQS .......................................................................................... 95Envío de mensajes en Amazon SQS .................................................................................. 96Envío y recepción de mensajes en Amazon SQS ................................................................. 96Recepción de mensajes en Amazon SQS ........................................................................... 98Recepción de mensajes mediante el sondeo largo de Amazon SQS ........................................ 98Habilitar el sondeo largo en Amazon SQS ........................................................................... 99Recibir mensajes utilizando la clase QueuePoller en Amazon SQS ........................................ 100Redireccionamiento de mensajes fallidos en Amazon SQS ................................................... 102Eliminación de una cola en Amazon SQS .......................................................................... 102Habilitar un recurso para publicarlo en una cola de Amazon SQS .......................................... 102Trabajar con una cola de mensajes fallidos en Amazon SQS ................................................ 103Especificación del tiempo de espera de visibilidad de los mensajes en Amazon SQS ................. 105

Consejos y trucos para AWS SDK for Ruby ....................................................................................... 107Sugerencias y trucos para Amazon EC2 ................................................................................... 107

Cambio de IP elásticas .................................................................................................... 107Historial de revisión ........................................................................................................................ 108

v

Page 6: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAcerca de esta guía

AWS SDK for Ruby Developer GuideBienvenido a AWS SDK for Ruby.

El AWS SDK for Ruby ayuda a eliminar la complejidad de la codificación al proporcionar clases de Rubypara casi todos los servicios de AWS, incluidos Amazon Simple Storage Service, Amazon Elastic ComputeCloud y Amazon DynamoDB. Para obtener una lista completa de los servicios compatibles con AWS SDKfor Ruby, consulte la sección Supported Services del archivo Readme de AWS SDK for Ruby.

Acerca de esta guíaEl AWS SDK for Ruby Developer Guide proporciona información sobre cómo instalar, configurar y utilizarAWS SDK for Ruby para crear aplicaciones Ruby que utilicen los servicios de AWS.

Esta guía contiene las siguientes secciones.

Introducción a AWS SDK para Ruby (p. 3)

Describe cómo configurar y utilizar AWS SDK for Ruby.Tutorial Hello World (p. 12)

Una guía paso a paso para crear una aplicación utilizando AWS SDK for Ruby.Programación con AWS SDK para Ruby (p. 16)

Ofrece información general sobre el desarrollo de software con AWS SDK for Ruby.Ejemplos de código de AWS SDK para Ruby (p. 22)

Proporciona ejemplos de código que los desarrolladores pueden utilizar para programar servicios deAWS con AWS SDK for Ruby.

Historial de revisión (p. 108)

Describe el historial de este documento.

Documentación y recursos adicionalesMás recursos para desarrolladores de AWS SDK for Ruby se encuentran en:

• AWS SDK for Ruby API Reference• Blog de desarrolladores• Foros de desarrolladores (debe disponer de una cuenta de AWS para el acceso a los foros)• Canal de Gitter• @awsforruby en Twitter• En GitHub:

• Releases (incluye código, gemas y documentación)• Source• Change log• Migration Guide• Problemas

1

Page 7: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideImplementación en la nube de AWS

• Feature requests• Upgrading notes

Implementación en la nube de AWSPuede utilizar los servicios de AWS, por ejemplo, AWS OpsWorks, CodeDeploy y AWS Elastic Beanstalkpara implementar la aplicación en la nube de AWS. Para implementar aplicaciones Ruby con ElasticBeanstalk, consulte Working with Ruby en la Elastic Beanstalk Developer Guide. Para implementar unaaplicación de Ruby on Rails con AWS OpsWorks, consulte Deploying Ruby on Rails Applications to AWSOpsWorks. Para obtener información general sobre los servicios de implementación de AWS, consulteOverview of Deployment Options on AWS.

2

Page 8: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideGuía de inicio rápido de AWS SDK for Ruby

Introducción a AWS SDK for RubySi es la primera vez que utiliza la AWS SDK for Ruby, debe comenzar aquí. Esta sección contieneinformación sobre cómo instalar, configurar y utilizar el SDK para crear una aplicación de Ruby y obteneracceso a Amazon S3.

Temas• Guía de inicio rápido de AWS SDK for Ruby (p. 3)• Instalación de AWS SDK for Ruby (p. 4)• Configuración de AWS SDK for Ruby (p. 5)• Uso de AWS SDK for Ruby REPL (p. 8)• Uso del SDK con Ruby on Rails (p. 8)• Migración de la versión 1 a la versión 2 de AWS SDK for Ruby (p. 9)

Guía de inicio rápido de AWS SDK for RubyEn esta sección se muestra cómo utilizar AWS SDK for Ruby para crear una sencilla aplicación de Rubyque enumere los buckets de Amazon S3.

• Si no ha instalado el SDK, consulte AWS SDK para Ruby (p. 4).• Si no ha configurado el SDK, consulte Configuración de AWS SDK para Ruby (p. 5).

Escribir el códigoEn el siguiente ejemplo se muestran los nombres de hasta 50 de sus buckets. Copie el código y guárdelocomo buckets.rb. Tenga en cuenta que aunque el objeto Resource se crea en la región us-west-2,Amazon S3 devuelve buckets a los que tiene acceso independientemente de la región.

require 'aws-sdk'

s3 = Aws::S3::Resource.new(region: 'us-west-2')

s3.buckets.limit(50).each do |b| puts "#{b.name}"end

Ejecutar el códigoEscriba el siguiente comando para ejecutar buckets.rb.

ruby buckets.rb

Nota para usuarios de WindowsCuando utiliza certificados SSL en Windows y ejecuta el código Ruby, verá un error similar al siguiente.

3

Page 9: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideInstalación de AWS SDK for Ruby

C:\Ruby>ruby buckets.rbC:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:921:in `connect': SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed (Seahorse::Client::NetworkingError) from C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:921:in `block in connect'

from C:/Ruby200-x64/lib/ruby/2.0.0/timeout.rb:66:in `timeout' from C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:921:in `connect' from C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:862:in `do_start' from C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:857:in `start'...

Para solucionar este problema, añada la siguiente línea a su archivo de código de Ruby, en algún lugarantes de la primera llamada a AWS.

Aws.use_bundled_cert!

Instalación de AWS SDK for RubyEsta sección incluye los requisitos previos y las instrucciones de instalación.

Requisitos previosAntes de instalar AWS SDK for Ruby, necesita disponer de una cuenta de AWS y la versión 1.9 o posteriorde Ruby.

Si no dispone de una cuenta de AWS, utilice el siguiente procedimiento para crear una.

Para inscribirse en AWS1. Abra http://aws.amazon.com/ y, a continuación, elija Crear una cuenta de AWS.2. Siga las instrucciones en línea.

Instalación de AWS SDK for RubySi su proyecto utiliza Bundler, introduzca la siguiente línea en el archivo Gemfile para añadir AWS SDKfor Ruby a su proyecto.

gem 'aws-sdk'

Si no usa Bundler, la forma más sencilla de instalar el SDK es utilizar RubyGems. Para instalar la últimaversión del SDK, utilice el siguiente comando.

gem install aws-sdk

Si falla el comando anterior en su sistema basado en Unix, utilice sudo para instalar el SDK, tal y como semuestra en el siguiente comando.

sudo gem install aws-sdk

4

Page 10: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideConfiguración de AWS SDK for Ruby

Configuración de AWS SDK for RubyObtenga información sobre cómo configurar AWS SDK for Ruby. Para utilizar el SDK, debe configurarlas credenciales de AWS o crear un token de acceso de AWS STS y definir la región de AWS que deseautilizar.

Configuración de las credenciales de AWSAntes de poder utilizar AWS SDK for Ruby para realizar una llamada a un servicio de AWS, debeconfigurar las credenciales de acceso de AWS que el SDK utilizará para verificar el acceso a los servicios yrecursos de AWS.

AWS SDK for Ruby busca las credenciales en el orden que se indica a continuación:

1. Configuración de las credenciales en un objeto del cliente (p. 6)2. Configuración de las credenciales mediante Aws.config (p. 6)3. Configuración de las credenciales mediante variables de entorno (p. 5)4. Configuración de las credenciales compartidas (p. 5)5. Configuración de las credenciales mediante IAM (p. 6)

En las siguientes secciones se describen las distintas maneras de configurar las credenciales,comenzando por el enfoque más flexible. Para obtener más información acerca de las credenciales deAWS y los enfoques recomendados para la administración de las credenciales, consulte Credenciales deseguridad de AWS en Amazon Web Services General Reference.

Configuración de las credenciales compartidasConfigure las credenciales compartidas en el archivo de perfil de credenciales de AWS del sistema local.

En sistemas basados en Unix, como Linux u OS X, este archivo se encuentra en la siguiente ubicación.

~/.aws/credentials

En Windows, el archivo se encuentra en la siguiente ubicación.

%HOMEPATH%\.aws\credentials

Este archivo debe tener el siguiente formato, donde default es el nombre del perfil de configuraciónpredeterminado que se hayan asignado a estas credenciales, your_access_key_id es el valor de laclave de acceso y your_secret_access_key es el valor de la clave de acceso secreta.

[default]aws_access_key_id = your_access_key_idaws_secret_access_key = your_secret_access_key

Configuración de las credenciales mediante variables de entornoEstablezca las variables de entorno AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEY.

Utilice el comando export para establecer estas variables en los sistemas basados en Unix, como Linux uOS X. En el siguiente ejemplo se establece el valor de la clave de acceso en your_access_key_id y elvalor de la clave de acceso secreta en your_secret_access_key.

5

Page 11: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de un token de acceso de AWS STS

export AWS_ACCESS_KEY_ID=your_access_key_idexport AWS_SECRET_ACCESS_KEY=your_secret_access_key

Para establecer estas variables en Windows, utilice el comando set, tal y como se muestra en el siguienteejemplo.

set AWS_ACCESS_KEY_ID=your_access_key_idset AWS_SECRET_ACCESS_KEY=your_secret_access_key

Configuración de las credenciales mediante Aws.configConfigure las credenciales en el código actualizando los valores en el hash Aws.config.

En el siguiente ejemplo se establece el valor de la clave de acceso en your_access_key_id y el valorde la clave de acceso secreta en your_secret_access_key. Todos los clientes o recursos que creeposteriormente utilizarán estas credenciales.

Aws.config.update({ credentials: Aws::Credentials.new('your_access_key_id', 'your_secret_access_key')})

Configuración de las credenciales en un objeto del clienteConfigure las credenciales en el código especificándolas al crear un cliente de AWS.

En el siguiente ejemplo se crea un cliente de Amazon S3 mediante la clave de accesoyour_access_key_id y la clave de acceso secreta your_secret_access_key.

s3 = Aws::S3::Client.new( access_key_id: 'your_access_key_id', secret_access_key: 'your_secret_access_key')

Configuración de las credenciales mediante IAMPara una instancia Amazon Elastic Compute Cloud, cree un rol de IAM y, a continuación, conceda a lainstancia Amazon EC2 acceso a dicho rol. Para obtener más información, consulte Roles de IAM paraAmazon EC2 en la Amazon EC2 User Guide for Linux Instances o Roles de IAM para Amazon EC2 en laAmazon EC2 User Guide for Windows Instances.

Creación de un token de acceso de AWS STSUtilice el método Aws::AssumeRoleCredentials para crear un token de acceso de AWS STS.

En el siguiente ejemplo se utiliza un token de acceso para crear un objeto de cliente de Amazon S3,donde linked::account::arn es el nombre de recurso de Amazon (ARN) del rol que se va a asumir, ysession-name es un identificador de la sesión del rol asumido.

role_credentials = Aws::AssumeRoleCredentials.new( client: Aws::STS::Client.new, role_arn: "linked::account::arn", role_session_name: "session-name")

s3 = Aws::S3::Client.new(credentials: role_credentials)

6

Page 12: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideConfiguración de una región

Configuración de una regiónDebe configurar una región cuando se utiliza la mayoría de los servicios de AWS. Puede configurar laregión de AWS de manera similar a la configuración de las credenciales de AWS. AWS SDK for Rubybusca una región en el orden que se indica a continuación:

• Configuración de la región en un objeto de recurso (p. 7)• Configuración de la región mediante Aws.config (p. 7)• Configuración de la región mediante variables de entorno (p. 7)

En el resto de esta sección se describe cómo configurar una región, comenzando por el enfoque másflexible.

Configuración de la región mediante variables de entornoConfigure la región mediante estableciendo la variable de entorno AWS_REGION.

Utilice el comando export para establecer esta variable en los sistemas basados en Unix, como Linux uOS X. En el siguiente ejemplo se establece la región en us-west-2.

export AWS_REGION=us-west-2

Para establecer esta variable en Windows, utilice el comando set. En el siguiente ejemplo se establece laregión en us-west-2.

set AWS_REGION=us-west-2

Configuración de la región mediante Aws.configConfigure la región añadiendo un valor region en el hash Aws.config. En el siguiente ejemplo seactualiza el hash Aws.config para utilizar la región us-west-1.

Aws.config.update({region: 'us-west-1'})

Todos los clientes o recursos que cree posteriormente estarán asociados a esta región.

Configuración de la región en un objeto de recursoConfigure la región al crear un cliente o recurso de AWS. En el siguiente ejemplo se crea un objeto derecurso de Amazon S3 en la región us-west-1.

s3 = Aws::S3::Resource.new(region: 'us-west-1')

Configuración de un punto de enlace no estándarSi necesita utilizar un punto de enlace no estándar en la región que ha seleccionado, añada una entradaendpoint en Aws.config o establezca el endpoint: al crear un cliente del servicio o un objeto derecurso. En el siguiente ejemplo se crea un objeto de recurso de Amazon S3 en el punto de enlaceother_endpoint.

s3 = Aws::S3::Resource.new(endpoint: other_endpoint)

7

Page 13: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideUso de AWS SDK for Ruby REPL

Uso de AWS SDK for Ruby REPLLos desarrolladores pueden utilizar aws.rb, la herramienta de la consola de línea de comandos interactivaREPL (read-evaluate-print loop), que forma parte de la gema aws-sdk-core.

Si bien aws.rb funciona con Interactive Ruby Shell (irb), recomendamos instalar pry porque proporcionaun entorno REPL más potente.

Utilice el siguiente comando para instalar pry.

gem install pry

Para utilizar aws.rb, llámelo en una ventana de la consola utilizando una de las siguientes líneas decomandos.

aws.rbaws.rb -v

La segunda línea de comando llama a REPL con registro en red HTTP extenso, que proporcionainformación sobre la comunicación entre AWS SDK for Ruby y AWS. Utilice esta línea de comandoscon precaución, ya que también conlleva trabajo extra que puede hacer que el código se ejecute másdespacio.

El REPL define un objeto auxiliar para cada clase de servicio. Escriba en minúscula el nombre del módulode servicio para obtener el nombre del objeto auxiliar. Por ejemplo, los nombres de los objetos auxiliaresde Amazon S3 y Amazon EC2 son s3 y ec2, respectivamente.

Uso del SDK con Ruby on RailsRuby on Rails proporciona un marco de desarrollo web para Ruby que facilita la creación de sitios web conRuby.

AWS SDK for Ruby proporciona una gema que permite una fácil integración con Rails. Puede utilizar AWSElastic Beanstalk, AWS OpsWorks o AWS CodeDeploy para implementar y ejecutar las aplicaciones deRails en la nube de AWS.

Integración de AWS SDK for Ruby con RailsAWS ofrece un archivo Gemfile, aws-sdk-rails, que admite la integración de AWS SDK for Ruby conRails. Puede ver su repositorio GitHub en https://github.com/aws/aws-sdk-rails.

Añada la gema al Gemfile de su aplicación, tal y como se muestra en el siguiente ejemplo.

gem 'aws-sdk-rails'

Como la gema incluye AWS SDK for Ruby, lo único que tiene que hacer es agregar la gema para añadirsoporte de AWS a su aplicación de Rails.

Soporte de Amazon SES para ActionMailerSi usa la gema aws-sdk-rails en un archivo config/environments de su proyecto de Rails (porejemplo, config/environments/production.rb), puede utilizar Amazon Simple Email Service(Amazon SES) como backend para la clase ActionMailer, tal y como se muestra en el siguienteejemplo.

8

Page 14: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideRegistro

config.action_mailer.delivery_method = :aws_sdk

Para obtener más información acerca de ActionMailer, consulte los conceptos básicos de Action Maileren el sitio web de Ruby on Rails.

RegistroLa gema aws-sdk-rails configura el registrador del SDK para utilizar Rails.logger.

La gema también configura los mensajes de registro del SDK para utilizar el nivel de registro :info.Puede cambiar el nivel de registro estableciendo :log_level en el hash Aws.config. En el siguienteejemplo, el nivel de registro se establece en :debug.

Aws.config.update({log_level: :debug})

Migración de la versión 1 a la versión 2 de AWSSDK for Ruby

El objetivo de este tema es ayudar a migrar de la versión 1 de AWS SDK for Ruby a la versión 2.

Uso en paraleloNo es necesario reemplazar la versión 1 de AWS SDK for Ruby por la versión 2. Puede utilizarlas de formaconjunta en la misma aplicación. Para obtener más información, consulte esta entrada del blog.

Un ejemplo rápido:

require 'aws-sdk-v1' # version 1require 'aws-sdk' # version 2

s3 = AWS::S3::Client.new # version 1s3 = Aws::S3::Client.new # version 2

No es necesario volver a escribir el código funcional de la versión 1 existente para comenzar a utilizar elSDK de la versión 2. Una estrategia de migración válida es escribir solo el nuevo código con respecto alSDK de la versión 2.

Diferencias generalesLa versión 2 difiere de la versión 1 en algunos aspectos importantes.

• El espacio de nombres raíz es distinto: Aws frente a AWS. Esto permite realizar un uso en paralelo.• Ahora Aws.config es un hash de Ruby simple, en lugar de un método.• Estrictas opciones del constructor: al construir un cliente o un objeto de recurso en el SDK de la versión

1, no se tienen en cuenta las opciones del constructor desconocidas. En la versión 2, las opciones delconstructor desconocidas activan un ArgumentError. Por ejemplo:

# version 1AWS::S3::Client.new(http_reed_timeout: 10)# oops, typo'd option is ignored

9

Page 15: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideDiferencias del cliente

# version 2Aws::S3::Client.new(http_reed_timeout: 10)# => raises ArgumentError

Diferencias del clienteEntre la versión 1 y 2, las clases del cliente presentan menos diferencias externas. Muchos clientes deservicios tendrán interfaces compatibles tras la construcción del cliente. Algunas de las diferencias másdestacadas:

• Aws::S3::Client: en la versión 1, la clase del cliente de Amazon S3 tiene codificación manual. Laversión 2 se genera a partir de un modelo de servicio. Los nombres de método y las entradas son muydiferentes en la versión 2.

• Aws::EC2::Client: la versión 2 utiliza nombre en plural para las listas de salida, mientras que laversión 1 utiliza el sufijo _set. Por ejemplo:

# version 1resp = AWS::EC2::Client.new.describe_security_groupsresp.security_group_set#=> [...]

# version 2resp = Aws::EC2::Client.new.describe_security_groupsresp.security_groups#=> [...]

• Aws::SWF::Client: la versión 2 utiliza respuestas estructuradas, mientras que la versión 1 utiliza hashde Ruby simples.

• Nombres distintos según la clase de servicio: la versión 2 utiliza un nombre diferente para los distintosservicios:• AWS::SimpleWorkflow se ha convertido en Aws::SWF• AWS::ELB se ha convertido en Aws::ElasticLoadBalancing• AWS::SimpleEmailService se ha convertido en Aws::SES

• Opciones de configuración de clientes: algunas de las opciones de configuración de la versión 1 hancambiado de nombre en la versión 2. Otras se han eliminado o reemplazado. A continuación, semuestran los principales cambios:• Se ha eliminado :use_ssl. La versión 2 utiliza SSL para todo. Para deshabilitar SSL debe configurar

un :endpoint que utilice http://.• :ssl_ca_file => :ssl_ca_bundle• :ssl_ca_path => :ssl_ca_directory• :ssl_ca_store añadido.• Ahora :endpoint debe ser un URI HTTP o HTTPS completo en lugar de un nombre de host.• Se han quitado las opciones :*_port de cada servicio y se han reemplazado por :endpoint.• :user_agent_prefix ahora es :user_agent_suffix

Diferencias en los recursosExisten importantes diferencias entre las interfaces de recurso de la versión 1 y la versión 2. Toda laversión 1 está codificada manualmente, mientras que las interfaces de recurso de la versión 2 se generana partir de un modelo. Las interfaces de recurso de la versión 2 son significativamente más coherentes.Algunas de las diferencias entre sistemas son:

10

Page 16: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideDiferencias en los recursos

• Clase de recurso independiente: en la versión 2, el nombre del servicio es un módulo, no una clase. Eneste módulo se encuentra la interfaz de recurso:

# version 1s3 = AWS::S3.new

# version 2s3 = Aws::S3::Resource.new

• Referencia a los recursos: el SDK de la versión 2 separa los métodos getter de las colecciones y losrecursos individuales en dos métodos diferentes:

# version 1s3.buckets['bucket-name'].objects['key'].delete

# version 2s3.bucket('bucket-name').object('key').delete

• Operaciones por lotes: en la versión 1, todas las operaciones por lotes eran utilidades con codificaciónmanual. En la versión 2, muchas operaciones por lotes son operaciones procesadas por lotes degeneración automática a través del API. Las interfaces procesadas por lotes de la versión 2 son muydistintas de la versión 1.

11

Page 17: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideUso de AWS SDK for Ruby en el programa

Tutorial Hello WorldEn este tutorial se muestra cómo utilizar AWS SDK for Ruby para crear un programa de línea de comandosque realiza algunas de las operaciones de Amazon S3 más comunes.

Uso de AWS SDK for Ruby en el programaAñada una declaración require en la parte superior del archivo de recurso de Ruby para utilizar lasclases y los métodos que proporciona AWS SDK for Ruby.

require 'aws-sdk'

Creación de un recurso de Amazon S3Cree un objeto Aws::S3::Resource en la región adecuada. En el siguiente ejemplo se crea un objetode recurso de Amazon S3 en la región us-west-2. Tenga en cuenta que la región no es un aspectoimportante porque los recursos de Amazon S3 no son específicos de una región.

s3 = Aws::S3::Resource.new(region: 'us-west-2')

Creación de un bucketPara almacenar cualquier elemento en Amazon S3, necesitará un bucket donde incluirlo.

Cree un objeto Aws::S3::Bucket. En el siguiente ejemplo se crea el bucket my_bucket con el nombre my-bucket.

my_bucket = s3.bucket('my-bucket')my_bucket.create

Añadir un archivo al bucketUtilice el método #upload_file para añadir un archivo al bucket. En el siguiente ejemplo se añade elarchivo denominado my_file al bucket denominado my-bucket.

name = File.basename 'my_file'obj = s3.bucket('my-bucket').object(name)obj.upload_file('my_file')

Mostrar el contenido de un bucketPara mostrar el contenido de un bucket, utilice el método Aws::S3::Bucket:Objects. En el siguiente ejemplose muestran hasta 50 elementos de bucket para el bucket my-bucket.

my_bucket.objects.limit(50).each do |obj|

12

Page 18: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuidePrograma completo

puts " #{obj.key} => #{obj.etag}"end

Programa completoA continuación se muestra el programa hello-s3.rb completo.

require 'aws-sdk'

NO_SUCH_BUCKET = "The bucket '%s' does not exist!"

USAGE = <<DOC

Usage: hello-s3 bucket_name [operation] [file_name]

Where: bucket_name (required) is the name of the bucket

operation is the operation to perform on the bucket: create - creates a new bucket upload - uploads a file to the bucket list - (default) lists up to 50 bucket items

file_name is the name of the file to upload, required when operation is 'upload'

DOC

# Set the name of the bucket on which the operations are performed# This argument is requiredbucket_name = nil

if ARGV.length > 0 bucket_name = ARGV[0]else puts USAGE exit 1end

# The operation to perform on the bucketoperation = 'list' # defaultoperation = ARGV[1] if (ARGV.length > 1)

# The file name to use with 'upload'file = nilfile = ARGV[2] if (ARGV.length > 2)

# Get an Amazon S3 resources3 = Aws::S3::Resource.new(region: 'us-west-2')

# Get the bucket by namebucket = s3.bucket(bucket_name)

case operationwhen 'create' # Create a bucket if it doesn't already exist if bucket.exists? puts "The bucket '%s' already exists!" % bucket_name else bucket.create puts "Created new S3 bucket: %s" % bucket_name end

13

Page 19: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjecución del programa

when 'upload' if file == nil puts "You must enter the name of the file to upload to S3!" exit end

if bucket.exists? name = File.basename file

# Check if file is already in bucket if bucket.object(name).exists? puts "#{name} already exists in the bucket" else obj = s3.bucket(bucket_name).object(name) obj.upload_file(file) puts "Uploaded '%s' to S3!" % name end else NO_SUCH_BUCKET % bucket_name end

when 'list' if bucket.exists? # Enumerate the bucket contents and object etags puts "Contents of '%s':" % bucket_name puts ' Name => GUID'

bucket.objects.limit(50).each do |obj| puts " #{obj.key} => #{obj.etag}" end else NO_SUCH_BUCKET % bucket_name end

else puts "Unknown operation: '%s'!" % operation puts USAGEend

Ejecución del programaPara mostrar el contenido de un bucket, utilice uno de los siguientes comandos, donde bucket-namees el nombre del bucket que se va a mostrar. No es necesario incluir list porque es la operaciónpredeterminada.

ruby hello-s3.rb bucket-name listruby hello-s3.rb bucket-name

Para crear un bucket, utilice el siguiente comando, donde bucket-name es el nombre del bucket quedesea crear.

ruby hello-s3.rb bucket-name create

Si Amazon S3 ya tiene un bucket denominado bucket-name, el servicio emite un mensaje de error y nose crea otra copia.

Después de crear el bucket, puede cargar un objeto en él. El siguiente comando añade your_file.txtal bucket.

14

Page 20: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuidePasos siguientes

ruby hello-s3.rb bucket-name upload your_file.txt

Pasos siguientesAhora que ya ha realizado la primera aplicación de AWS SDK for Ruby, a continuación se ofrecen algunassugerencias para ampliar el código que acaba de escribir:

• Utilice la colección buckets de la clase Aws::S3::Resource para obtener una lista de los buckets.• Utilice el método #get de la clase Bucket para descargar un objeto del bucket.• Utilice el código que se indica en Añadir un archivo al bucket (p. 12) para confirmar que el elemento

existe en el bucket y, a continuación, actualice dicho elemento.

15

Page 21: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideConsejo de depuración: Obtener

información del rastro de red de un cliente

Programación con AWS SDK forRuby

Esta sección proporciona información sobre el desarrollo de software con AWS SDK for Ruby, incluidocómo utilizar algunas de las funciones avanzadas del SDK.

Temas• Consejo de depuración: Obtener información del rastro de red de un cliente (p. 16)• Stub: respuestas y errores de cliente (p. 17)• Paginación de los datos de respuesta (p. 18)• Uso de esperadores (p. 19)• Especificación de la duración del tiempo de espera de un cliente (p. 21)

Consejo de depuración: Obtener información delrastro de red de un cliente

Puede obtener información de rastro de red de un cliente de AWS cuando lo crea estableciendo la opciónhttp_wire_trace. Esta información ayuda a diferenciar los cambios de cliente, los problemas deservicio y los errores de los usuarios. En el siguiente ejemplo se crea un cliente de Amazon S3 con rastreode red habilitado.

s3 = Aws::S3::Client.new(http_wire_trace: true)

Dado el código y el argumento bucket_name siguientes, la salida muestra un mensaje que indica si existeun bucket con ese nombre.

require 'aws-sdk'

s3 = Aws::S3::Resource.new(client: Aws::S3::Client.new(http_wire_trace: true))

if s3.bucket(ARGV[0]).exists? puts "Bucket #{ARGV[0]} exists"else puts "Bucket #{ARGV[0]} does not exist"end

Si el bucket existe, la salida tiene un aspecto parecido al siguiente, donde ACCESS_KEY es el valor de laclave de acceso. (Las devoluciones se añaden a la línea HEAD para favorecer la legibilidad).

opening connection to bucket_name.s3-us-west-1.amazonaws.com:443...openedstarting SSL for bucket_name.s3-us-west-1.amazonaws.com:443...SSL established<- "HEAD / HTTP/1.1\r\n Content-Type: \r\n Accept-Encoding: \r\n User-Agent: aws-sdk-ruby2/2.2.7 ruby/2.1.7 x64-mingw32\r\n X-Amz-Date: 20160121T191751Z\r\n

16

Page 22: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideStub: respuestas y errores de cliente

Host: bucket_name.s3-us-west-1.amazonaws.com\r\n X-Amz-Content-Sha256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\r\n Authorization: AWS4-HMAC-SHA256 Credential=ACCESS_KEY/20160121/us-west-1/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=2ca8301c5e829700940d3cc3bca2a3e8d79d177f2c046c34a1a285770db63820\r\n Content-Length: 0\r\n Accept: */*\r\n \r\n"-> "HTTP/1.1 301 Moved Permanently\r\n"-> "x-amz-bucket-region: us-west-2\r\n"-> "x-amz-request-id: F3C75F33EF0792C4\r\n"-> "x-amz-id-2: N6BzRLx8b68NmF50g1IxLzT+E4uWPuAIRe7Pl4XKl5STT4tfNO7gBsO8qrrAnG4CbVpU0iIRXmk=\r\n"-> "Content-Type: application/xml\r\n"-> "Transfer-Encoding: chunked\r\n"-> "Date: Thu, 21 Jan 2016 19:17:54 GMT\r\n"-> "Server: AmazonS3\r\n"-> "\r\n"Conn keep-aliveBucket bucket_name exists

Stub: respuestas y errores de clienteObtenga información sobre este proceso en una aplicación AWS SDK for Ruby.

Stub: respuestas de clienteCuando se aplica a una respuesta, AWS SDK for Ruby deshabilita el tráfico de red y el cliente devuelvedatos de referencia (stub). Si no se suministran datos de referencia, el cliente devuelve:

• Las listas como matrices vacías• Los mapeos como hashes vacíos• Los valores numéricos como cero• Las fechas como now

El siguiente ejemplo devuelve nombres stub para la lista de buckets de Amazon S3.

require 'aws-sdk'

s3 = Aws::S3::Client.new(stub_responses: true)

bucket_data = s3.stub_data(:list_buckets, :buckets => [{name:'aws-sdk'}, {name:'aws-sdk2'}])s3.stub_responses(:list_buckets, bucket_data)bucket_names = s3.list_buckets.buckets.map(&:name)

# List each bucket by namebucket_names.each do |name| puts nameend

La ejecución de este código muestra lo siguiente.

aws-sdk

17

Page 23: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideStub: errores de cliente

aws-sdk2

Note

Una vez proporcionados datos vacíos o de referencia (stub), se dejan de aplicar los valorespredeterminados a los atributos de instancia restantes. Esto significa que, en el ejemplo anterior,el atributo de instancia restante creation_date no es now sino nil.

AWS SDK for Ruby valida los datos falsos (stub). Si pasa datos del tipo equivocado, se genera unaexcepción ArgumentError. Por ejemplo, si en lugar de la asignación anterior a bucket_data, sehubiera usado lo siguiente:

bucket_data = s3.stub_data(:list_buckets, buckets:['aws-sdk', 'aws-sdk2'])

AWS SDK for Ruby generaría dos excepciones ArgumentError.

expected params[:buckets][0] to be a hashexpected params[:buckets][1] to be a hash

Stub: errores de clienteTambién puede proporcionar datos stub para los errores que AWS SDK for Ruby genera para métodosespecíficos. El ejemplo siguiente muestra Caught Timeout::Error error calling head_bucketon aws-sdk.

require 'aws-sdk'

s3 = Aws::S3::Client.new(stub_responses: true)s3.stub_responses(:head_bucket, Timeout::Error)

begin s3.head_bucket({bucket: 'aws-sdk'})rescue Exception => ex puts "Caught #{ex.class} error calling 'head_bucket' on 'aws-sdk'"end

Paginación de los datos de respuestaAlgunas llamadas a AWS proporcionan respuestas paginadas para limitar la cantidad de datos que sedevuelve con cada respuesta. Una página de datos representa un máximo de 1000 elementos.

Las respuestas paginadas se pueden enumerarLa forma más sencilla de administrar datos de respuesta paginados es usar el enumerador integrado en elobjeto de respuesta, como se muestra en el siguiente ejemplo.

s3 = Aws::S3::Client.new

s3.list_objects(bucket:'aws-sdk').each do |response| puts response.contents.map(&:key)end

Esto produce un objeto de respuesta por cada llamada realizada a la API y enumera los objetos del bucketdesignado. El SDK recupera páginas adicionales de datos para completar la solicitud.

18

Page 24: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministrar respuestas paginadas manualmente

Administrar respuestas paginadas manualmentePara controlar la paginación, use el método next_page? de la respuesta para comprobar si haymás páginas que recuperar o use el método last_page? para verificar que no hay más páginas querecuperar.

Si hay más páginas, utilice el método next_page (observe que no es ?) para recuperar la siguientepágina de resultados, como se muestra en el siguiente ejemplo.

s3 = Aws::S3::Client.new

# Get the first page of dataresponse = s3.list_objects(bucket:'aws-sdk')

# Get additional pageswhile response.next_page? do response = response.next_page # Use the response data here...end

Note

Si llama al método next_page y no hay más páginas para recuperar, el SDK genera unaexcepción Aws::PageableResponse::LastPageError.

Clases de datos paginadosLos datos paginados en AWS SDK for Ruby los gestiona la clase Aws::PageableResponse, que se incluyecon Seahorse::Client::Response para proporcionar acceso a los datos paginados.

Uso de esperadoresLos esperadores son métodos de utilidad que sondean si un determinado estado se produce en un cliente.Los esperadores pueden fallar transcurrido un número de intentos en un intervalo de sondeo definido parael cliente del servicio. Para ver un ejemplo de cómo se utiliza un esperador, consulte Creación de una tablasimple con una única clave principal (p. 30).

Llamada a un esperadorPara invocar un esperador, llame a #wait_until en el cliente del servicio. En el siguiente ejemplo, unesperador espera hasta que la instancia i-12345678 se esté ejecutando antes de continuar.

ec2 = Aws::EC2::Client.new

begin ec2.wait_until(:instance_running, instance_ids:['i-12345678']) puts "instance running"rescue Aws::Waiters::Errors::WaiterFailed => error puts "failed waiting for instance running: #{error.message}"end

El primer parámetro corresponde al nombre del esperador, que es específico del cliente del servicio, eindica la operación que se está esperado. El segundo parámetro es un hash de los parámetros que setransfieren al método del cliente que ha llamado el esperador, lo cual varía según el nombre del esperador.

19

Page 25: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideErrores de espera

Para obtener una lista de las operaciones a las que el esperador puede esperar y los métodos delcliente que se llaman en cada operación, consulte la documentación de los campos #waiter_names y#wait_until para el cliente que esté utilizando.

Errores de esperaLos esperadores pueden fallar con cualquiera de las siguientes excepciones:

Aws::Waiters::Errors::FailureStateError

Se ha producido un estado de error durante la espera.Aws::Waiters::Errors::NoSuchWaiterError

No se ha definido el nombre del esperador especificado para el cliente que se está utilizando.Aws::Waiters::Errors::TooManyAttemptsError

El número de intentos ha superado el valor max_attempts del esperador.Aws::Waiters::Errors::UnexpectedError

Se ha producido un error inesperado durante la espera.Aws::Waiters::Errors::WaiterFailed

Se ha superado uno de los estados de espera o se ha producido otro error durante la espera.

Todos estos errores, excepto NoSuchWaiterError, se basan en WaiterFailed. Para detectar erroresen un esperador, utilice WaiterFailed, tal y como se muestra en el siguiente ejemplo.

rescue Aws::Waiters::Errors::WaiterFailed => error puts "failed waiting for instance running: #{error.message}"end

Configuración de un esperadorCada esperador tiene un intervalo de sondeo predeterminado y un número máximo de intentos quehará antes de devolver el control al programa. Para establecer estos valores, utilice los parámetrosmax_attempts y delay: en la llamada a #wait_until. En el siguiente ejemplo se espera hasta 25segundos, realizando un sondeo cada 5 segundos.

# Poll for ~25 secondsclient.wait_until(...) do |w| w.max_attempts = 5 w.delay = 5end

Para deshabilitar los errores de espera, establezca el valor de cualquiera de estos parámetros en nil.

Ampliación de un esperadorPara modificar el comportamiento de los esperadores, puede registrar las devoluciones que se activanantes de cada intento de sondeo y antes del periodo de espera.

En el siguiente ejemplo se implementa un retardo exponencial en un esperador duplicando el tiempo quese debe esperar en cada intento.

ec2 = Aws::EC2::Client.new

20

Page 26: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEspecificación de la duración deltiempo de espera de un cliente

ec2.wait_until(:instance_running, instance_ids:['i-12345678']) do |w| w.interval = 0 # disable normal sleep w.before_wait do |n, resp| sleep(n ** 2) endend

En el siguiente ejemplo se deshabilita el número máximo de intentos y, en su lugar, se espera 1 hora(3 600 segundos) antes de que se produzca el error.

started_at = Time.nowclient.wait_until(...) do |w| # Disable max attempts w.max_attempts = nil

# Poll for 1 hour, instead of a number of attempts before_wait do |attempts, response| throw :failure if Time.now - started_at > 3600 endend

Especificación de la duración del tiempo de esperade un cliente

El siguiente ejemplo crea un cliente de Amazon S3 en la región us-west-2 y especifica esperar 5segundos entre dos reintentos en cada operación de cliente. De forma predeterminada, el SDK realizahasta tres reintentos, dejando transcurrir 15 segundos entre los reintentos, lo que equivale a un total decuatro intentos. Por tanto, una operación podría tardar 60 segundos en agotar el tiempo de espera, por loque el ejemplo podría tardar 15 segundos.

s3 = Aws::S3::Client.new(region: 'us-west-2', retry_limit: 2, http_open_timeout: 5)

21

Page 27: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de Amazon CloudWatch

Ejemplos de código de AWS SDK forRuby

En esta sección se proporcionan ejemplos que pueden utilizarse para tener acceso a los servicios de AWSmediante AWS SDK for Ruby.

Temas• Ejemplos de Amazon CloudWatch (p. 22)• Ejemplos de Amazon DynamoDB (p. 29)• Ejemplos de Amazon EC2 (p. 33)• Ejemplos de AWS Elastic Beanstalk (p. 50)• Ejemplos de AWS Identity and Access Management (p. 52)• Ejemplos de Lambda (p. 61)• Ejemplos de Amazon Relational Database Service (p. 64)• Ejemplos de Amazon S3 (p. 68)• Ejemplos de Amazon SNS (p. 91)• Ejemplos de Amazon SQS (p. 94)

Ejemplos de Amazon CloudWatchPuede utilizar los siguientes ejemplos para acceder a Amazon CloudWatch (CloudWatch) medianteAWS SDK for Ruby. Para obtener más información acerca de CloudWatch, consulte la Guía paradesarrolladores de CloudWatch.

Ejemplos

Temas• Obtener información acerca de todas las alarmas (p. 22)• Creación de una alarma (p. 23)• Habilitación y deshabilitación de las acciones de alarma (p. 24)• Obtener información sobre métricas personalizadas (p. 25)• Envío de eventos a Amazon CloudWatch Events (p. 26)

Obtener información acerca de todas las alarmasEn el siguiente ejemplo se muestra información acerca de las alarmas de CloudWatch.

require 'aws-sdk'

client = Aws::CloudWatch::Client.new(region: 'us-west-2')

# use client.describe_alarms({alarm_names: ['Name1', 'Name2']})# to get information about alarms Name1 and Name2resp = client.describe_alarms

22

Page 28: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una alarma

resp.metric_alarms.each do |alarm| puts 'Name: ' + alarm.alarm_name puts 'State: ' + alarm.state_value puts ' reason: ' + alarm.state_reason puts 'Metric: ' + alarm.metric_name puts 'Namespace: ' + alarm.namespace puts 'Statistic: ' + alarm.statistic puts 'Dimensions (' + alarm.dimensions.length.to_s + '):'

alarm.dimensions.each do |d| puts ' Name: ' + d.name puts ' Value: ' + d.value end

puts 'Period: ' + alarm.period.to_s puts 'Unit: ' + alarm.unit.to_s puts 'Eval periods: ' + alarm.evaluation_periods.to_s puts 'Threshold: ' + alarm.threshold.to_s puts 'Comp operator: ' + alarm.comparison_operator putsend

Creación de una alarmaEn el siguiente ejemplo se crea una alarma de CloudWatch my-alarma que envía un mensaje a travésdel tema de Amazon SNS con el ARN ARN cuando el bucket de Amazon S3 my-bucket tiene más de 50elementos en un periodo de 24 horas.

require 'aws-sdk'

# Placeholder for put_metric_alarm argsargs = {}args[:alarm_name] = 'my-alarm'args[:alarm_description] = 'Triggers alarm when S3 bucket my-bucket has more than 50 items'args[:alarm_actions] = 'ARN'args[:namespace] = 'AWS/S3'args[:metric_name] = 'NumberOfObjects'

dim1 = {}dim1[:name] = 'BucketName'dim1[:value] = 'my-bucket'

dim2 = {}dim2[:name] = 'StorageType'dim2[:value] = 'AllStorageTypes'

dimensions = []

dimensions << dim1dimensions << dim2

args[:dimensions] = dimensions

args[:statistic] = 'Maximum'

# NumberOfObjects REQUIRES this valueargs[:period] = 86400

# NumberOfObjects REQUIRES this valueargs[:unit] = nil

args[:evaluation_periods] = 1args[:threshold] = 50

23

Page 29: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideHabilitación y deshabilitación de las acciones de alarma

args[:comparison_operator] = 'GreaterThanThreshold'

cw = Aws::CloudWatch::Client.new(region: 'us-west-2')

cw.put_metric_alarm(args)

Habilitación y deshabilitación de las acciones dealarmaUna alarma de Amazon CloudWatch vigila una métrica determinada durante el periodo especificado. Laalarma de CloudWatch realiza una o varias acciones según el valor de la métrica con respecto a un umbraldeterminado durante varios períodos de tiempo. Para obtener más información, consulte Creating AmazonCloudWatch Alarms.

En este ejemplo, va a utilizar AWS SDK for Ruby con CloudWatch para:

1. Habilite una acción para una alarma de CloudWatch medianteAws::CloudWatch::Client#put_metric_alarm.

2. Desactive todas las acciones para una alarma medianteAws::CloudWatch::Client#disable_alarm_actions.

El código completo de este ejemplo está disponible en GitHub.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También debe sustituir arn:aws:sns:REGION-ID:ACCOUNT-ID:TOPIC-NAME por el ARN de un tema deAmazon SNS válido.

Ejemplorequire 'aws-sdk'

# Uncomment for Windows.# Aws.use_bundled_cert!

cw = Aws::CloudWatch::Client.new(region: 'us-east-1')

# Enable an action for an Amazon CloudWatch alarm.# If the alarm does not exist, create it.# If the alarm exists, update its settings.alarm_name = "TooManyObjectsInBucket"

cw.put_metric_alarm({ alarm_name: alarm_name, alarm_description: "Alarm whenever an average of more than one object exists in the specified Amazon S3 bucket for more than one day.", actions_enabled: true, # Run actions if the alarm's state changes. metric_name: "NumberOfObjects", alarm_actions: [ "arn:aws:sns:REGION-ID:ACCOUNT-ID:TOPIC-NAME" ], # Notify this Amazon SNS topic only if the alarm's state changes to ALARM.

24

Page 30: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información sobre métricas personalizadas

namespace: "AWS/S3", statistic: "Average", dimensions: [ { name: "BucketName", value: "my-bucket" }, { name: "StorageType", value: "AllStorageTypes" } ], period: 86400, # Daily (24 hours * 60 minutes * 60 seconds = 86400 seconds). unit: "Count", evaluation_periods: 1, # More than one day. threshold: 1, # One object. comparison_operator: "GreaterThanThreshold" # More than one object.})

# Disable all actions for the alarm.cw.disable_alarm_actions({ alarm_names: [ alarm_name ]})

Obtener información sobre métricas personalizadasUna alarma CloudWatch vigila una métrica única durante el periodo de tiempo que se especifique. Laalarma de CloudWatch realiza una o varias acciones según el valor de la métrica con respecto a un umbraldeterminado durante varios períodos de tiempo. Para obtener más información, consulte Creating AmazonCloudWatch Alarms.

En este ejemplo, va a utilizar AWS SDK for Ruby con CloudWatch para:

1. Enviar métricas personalizadas a CloudWatch utilizando Aws::CloudWatch::Client#put_metric_data.2. Obtener información sobre métricas personalizadas usando Aws::CloudWatch::Client#list_metrics-

instance.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

Ejemplorequire 'aws-sdk'

# Uncomment for Windows.# Aws.use_bundled_cert!

cw = Aws::CloudWatch::Client.new(region: 'us-east-1')

# Send custom metrics to Amazon CloudWatch.# In this example, add metrics to the custom namespace "SITE/TRAFFIC":# For the custom dimension named "SiteName", for the value named "example.com", add# "UniqueVisitors" of 5885 and "UniqueVisits" of 8628.

25

Page 31: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEnvío de eventos a Amazon CloudWatch Events

# For the custom dimension named "PageURL", for the value named "my-page.html", add# "PageViews" of 18057.cw.put_metric_data({ namespace: "SITE/TRAFFIC", metric_data: [ { metric_name: "UniqueVisitors", dimensions: [ { name: "SiteName", value: "example.com" } ], value: 5885.0, unit: "Count" }, { metric_name: "UniqueVisits", dimensions: [ { name: "SiteName", value: "example.com" } ], value: 8628.0, unit: "Count" }, { metric_name: "PageViews", dimensions: [ { name: "PageURL", value: "my-page.html" } ], value: 18057.0, unit: "Count" } ]})

# Get information about custom metrics.list_metrics_output = cw.list_metrics({ namespace: "SITE/TRAFFIC"})

list_metrics_output.metrics.each do |metric| puts metric.metric_name metric.dimensions.each do |dimension| puts "#{dimension.name} = #{dimension.value}" end puts "\n"end

Envío de eventos a Amazon CloudWatch EventsEventos de CloudWatch proporciona un flujo casi en tiempo real de eventos del sistema que describencambios en recursos de AWS en funciones de AWS Lambda u otros destinos. Para obtener másinformación, consulte ¿Qué es Amazon CloudWatch Events?. En este ejemplo, va a utilizar AWS SDK forRuby con Eventos de CloudWatch para:

1. Crear una regla en Eventos de CloudWatch mediante Aws::CloudWatchEvents::Client#put_rule.2. Añadir un destino a la regla mediante Aws::CloudWatchEvents::Client#put_targets.

26

Page 32: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEnvío de eventos a Amazon CloudWatch Events

3. Enviar un evento a Eventos de CloudWatch para que coincida con la regla.4. Ver los resultados en Amazon CloudWatch Logs y las métricas mediante

Aws::CloudWatch::Client#get_metric_statistics y Aws::CloudWatchLogs::Client#describe_log_streams.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También es necesario:

• Reemplazar el valor de marcador asignado a lambda_function_arn por el ARN de una función Lambdareal.1. Crear una función de Lambda, tal y como se describe aquí.2. Nombrar la función LogEC2InstanceStateChange.3. Para un rol, seleccione Choose an Existing Role. Para la función existente, seleccione

lambda_basic_execution.4. Después de crear la función, copie el ARN y péguelo en el código.

• Reemplace el valor de marcador asignado a cwe_service_role_arn por el ARN de un rol de servicio deAWS IAM adecuado.1. En la consola de IAM, cree un rol y adjunte una política que conceda acceso completo a Eventos de

CloudWatch.2. Asegúrese de que el rol tiene una relación de confianza para events.amazonaws.com. Para ver un

ejemplo de política y rol, consulte los comentarios en el código de ejemplo en GitHub.3. Después de crear el rol, adjunte la política y establezca la relación de confianza, copie el ARN del rol

y péguelo en el código.• Reemplace el valor de marcador asignado a instance_id por el ID de una instancia Amazon EC2 real.

Ejemplo

require 'aws-sdk'

# Uncomment for Windows.# Aws.use_bundled_cert!

cwe = Aws::CloudWatchEvents::Client.new(region: 'us-east-1')

# Replace this value with the ARN of the AWS Lambda function you created earlier.lambda_function_arn = "arn:aws:lambda:REGION-ID:ACCOUNT-ID:function:LogEC2InstanceStateChange"

# Replace this value with the ARN of the AWS IAM service role you created earlier.cwe_service_role_arn = "arn:aws:iam::ACCOUNT-ID:role/SERVICE-ROLE-NAME"

# Create a rule in Amazon CloudWatch Events.rule_name = "my-ec2-rule"

# The rule will use this pattern to route the event to the target.# This pattern is used whenever an Amazon EC2 instance begins running.event_pattern = { "source" => [

27

Page 33: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEnvío de eventos a Amazon CloudWatch Events

"aws.ec2" ], "detail-type" => [ "EC2 Instance State-change Notification" ], "detail" => { "state" => [ "running" ] }}.to_json

cwe.put_rule({ name: rule_name, event_pattern: event_pattern, state: "ENABLED", role_arn: cwe_service_role_arn})

# Add a target to the rule.cwe.put_targets({ rule: rule_name, targets: [ { id: "my-rule-target", arn: lambda_function_arn } ]})

# To test the rule, stop and then restart an existing Amazon EC2 instance.# For example:ec2 = Aws::EC2::Client.new(region: 'us-east-1')

# Replace this with an actual instance ID.instance_id = "i-INSTANCE-ID"

puts "Attempting to stop the instance. This may take a few minutes..."

ec2.stop_instances({ instance_ids: [ instance_id ]})

# Make sure the instance is stopped before attempting to restart it.ec2.wait_until(:instance_stopped, instance_ids: [ instance_id ])

puts "Attempt to restart the instance. This may take a few minutes..."

ec2.start_instances({ instance_ids: [ instance_id ]})

# Make sure the instance is running before continuing on.ec2.wait_until(:instance_running, instance_ids: [ instance_id ])

# See if and when the rule was triggered.cw = Aws::CloudWatch::Client.new(region: 'us-east-1')

invocations = cw.get_metric_statistics({ namespace: "AWS/Events", metric_name: "Invocations", dimensions: [ { name: "RuleName", value: rule_name, },

28

Page 34: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de Amazon DynamoDB

], start_time: Time.now - 600, # Look back over the past 10 minutes to see if the rule was triggered (10 minutes * 60 seconds = 600 seconds). end_time: Time.now, period: 60, # Look back every 60 seconds over those past 10 minutes to see how many times the rule may have been triggered. statistics: [ "Sum" ], unit: "Count"})

if invocations.datapoints.count > 0 puts "Rule invocations:" invocations.datapoints.each do |datapoint| puts " #{datapoint.sum} invocation(s) at #{datapoint.timestamp}" endelse puts "No rule invocations."end

# View the latest related log in Amazon CloudWatch Logs.cwl = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')

describe_log_streams_response = cwl.describe_log_streams({ log_group_name: "/aws/lambda/LogEC2InstanceStateChange", order_by: "LastEventTime", descending: true})

get_log_events_response = cwl.get_log_events({ log_group_name: "/aws/lambda/LogEC2InstanceStateChange", log_stream_name: describe_log_streams_response.log_streams[0].log_stream_name # Get the latest log stream only.})

puts "\nLog messages:\n\n"

get_log_events_response.events.each do |event| puts event.messageend

Ejemplos de Amazon DynamoDBPuede utilizar los siguientes ejemplos para obtener acceso a los servicios de Amazon DynamoDB conAWS SDK for Ruby. Para obtener más información acerca de DynamoDB, consulte la documentación deAmazon DynamoDB. En concreto, consulte Ruby and DynamoDB para obtener información sobre cómo:

• Crear una tabla y cargar datos de ejemplo en formato JSON.• Realizar operaciones de creación, lectura, actualización y eliminación en la tabla.• Ejecutar consultas sencillas.

El tema también proporciona un enlace a una versión de DynamoDB, descargable que incluye una interfazweb interactiva para que pueda experimentar con DynamoDB sin conexión.

Ejemplos

Temas• Obtener información acerca de todas las tablas (p. 30)• Creación de una tabla simple con una única clave principal (p. 30)

29

Page 35: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información acerca de todas las tablas

• Añadir un elemento a una tabla (p. 31)• Obtener información sobre los elementos de una tabla (p. 31)• Obtener información acerca de un elemento específico de una tabla (p. 31)• Actualización de una tabla (p. 32)• Creación de un índice (p. 32)

Obtener información acerca de todas las tablasEn el siguiente ejemplo se muestran los nombres y el número de elementos que tiene cada tabla de laregión us-west-2.

require 'aws-sdk'

dynamoDB = Aws::DynamoDB::Resource.new(region: 'us-west-2') dynamoDB.tables.each do |t| puts "Name: #{t.name}" puts "#Items: #{t.item_count}"end

Creación de una tabla simple con una única claveprincipalEn el siguiente ejemplo se crea la tabla Users con tres atributos: ID, FirstName y LastName en laregión us-west-2.

La llamada a wait_until impide que se utilice la tabla hasta que DynamoDB la haya creado. De formapredeterminada, el método wait_until del cliente de DynamoDB comprueba cada 20 segundos, hastaun máximo de 500 segundos, si la tabla se ha creado.

require 'aws-sdk'

attribute_defs = [ { attribute_name: 'ID', attribute_type: 'N' }, { attribute_name: 'FirstName', attribute_type: 'S' }, { attribute_name: 'LastName', attribute_type: 'S' }]

key_schema = [ { attribute_name: 'ID', key_type: 'HASH' }]

index_schema = [ { attribute_name: 'FirstName', key_type: 'HASH' }, { attribute_name: 'LastName', key_type: 'RANGE' }]

global_indexes = [{ index_name: 'LastNameFirstNameIndex', key_schema: index_schema, projection: { projection_type: 'ALL' }, provisioned_throughput: { read_capacity_units: 5, write_capacity_units: 10 }}]

request = { attribute_definitions: attribute_defs, table_name: 'Users',

30

Page 36: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAñadir un elemento a una tabla

key_schema: key_schema, global_secondary_indexes: global_indexes, provisioned_throughput: { read_capacity_units: 5, write_capacity_units: 10 }}

dynamodb_client = Aws::DynamoDB::Client.new(region: 'us-west-2')

dynamodb_client.create_table(request)dynamodb_client.wait_until(:table_exists, table_name: 'Users')

Añadir un elemento a una tablaEn el siguiente ejemplo se añade un elemento con el valor ID de 123456, el valor FirstName de John y elvalor LastName de Doe a la tabla Users de la región us-west-2.

require 'aws-sdk'

dynamoDB = Aws::DynamoDB::Resource.new(region: 'us-west-2')

table = dynamoDB.table('Users')

table.put_item({ item: { "ID" => 123456, "FirstName" => 'Snoop', "LastName" => 'Doug'}})

Obtener información sobre los elementos de una tablaEl siguiente ejemplo muestra un máximo de 50 elementos de la tabla Users en la región us-west-2.

require 'aws-sdk'

dynamoDB = Aws::DynamoDB::Resource.new(region: 'us-west-2')

table = dynamoDB.table('Users')

scan_output = table.scan({ limit: 50, select: "ALL_ATTRIBUTES"})

scan_output.items.each do |item| keys = item.keys

keys.each do |k| puts "#{k}: #{item[k]}" endend

Obtener información acerca de un elemento específicode una tablaEn el siguiente ejemplo se muestran el nombre y los apellidos de un elemento con el ID de 123456 en latabla Users de la región us-west-2.

31

Page 37: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideActualización de una tabla

require 'aws-sdk'

dynamoDB = Aws::DynamoDB::Resource.new(region: 'us-west-2')

table = dynamoDB.table('Users')

resp = table.get_item({ key: { 'ID' => 123456 }})

first_name = resp.item['FirstName']last_name = resp.item['LastName'] puts "First name: #{first_name}"puts "Last name: #{last_name}"

Actualización de una tablaEn el siguiente ejemplo se actualizan todos los elementos de la tabla Users en la región us-west-2 paraincluir un nuevo campo, airmiles, y establece el valor de 10 000.

require 'aws-sdk'

dynamoDB = Aws::DynamoDB::Resource.new(region: 'us-west-2')

table = dynamoDB.table('Users')

# Get the IDs of all of the usersresp = table.scan({ select: "ALL_ATTRIBUTES" })

resp.items.each do |item| id = item['ID'] request = { key: { 'ID' => id }, update_expression: 'set airmiles=:pVal', expression_attribute_values: { ':pVal' => '10000' } }

# Update the item in the table: table.update_item(request)end

Creación de un índiceEn el siguiente ejemplo se añade un índice nuevo, air-mileage-index, a la tabla Users de la regiónus-west-2. Una vez que el estado del índice es ACTIVE, puede buscar elementos de la tabla basándoseen el valor de su airmiles.

require 'aws-sdk'

request = { attribute_definitions: [ { attribute_name: 'airmiles', attribute_type: 'N', }, ], table_name: 'Users',

32

Page 38: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de Amazon EC2

global_secondary_index_updates: [ { create: { index_name: 'air-mileage-index', key_schema: [ { attribute_name: 'airmiles', key_type: 'HASH', }, ], projection: { projection_type: 'ALL', }, provisioned_throughput: { read_capacity_units: 5, write_capacity_units: 10, }, }, }, ],}

dynamoDB = Aws::DynamoDB::Client.new(region: 'us-west-2')

dynamoDB.update_table(request)

Ejemplos de Amazon EC2Puede utilizar los siguientes ejemplos para acceder a Amazon Elastic Compute Cloud (Amazon EC2)mediante AWS SDK for Ruby. Para obtener más información acerca de Amazon EC2, consulte ladocumentación de Amazon EC2.

Ejemplos

Temas• Creación de una VPC (p. 34)• Creación de una gateway de Internet y su asociación a una VPC (p. 34)• Crear una subred pública (p. 34)• Creación de una tabla de ruteo y su asociación a una subred (p. 35)• Uso de direcciones IP elásticas en Amazon EC2 (p. 35)• Creación de un grupo de seguridad (p. 37)• Trabajar con grupos de seguridad en Amazon EC2 (p. 37)• Trabajar con pares de claves (p. 40)• Obtener información acerca de todas las instancias (p. 43)• Obtener información acerca de todas las instancias con un valor de etiqueta específico (p. 43)• Obtener información acerca de una instancia específica (p. 44)• Creación de una instancia (p. 44)• Parada de una instancia (p. 45)• Iniciar una instancia (p. 45)• Reinicio de una instancia (p. 45)• Administración de instancias Amazon EC2 en Amazon EC2 (p. 46)• Terminación de una instancia (p. 47)

33

Page 39: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una VPC

• Obtener información sobre las regiones y las zonas de disponibilidad (p. 48)

Creación de una VPCEn el siguiente ejemplo se crea la nube virtual privada (VPC) MyGroovyVPC con el bloque de CIDR10.200.0.0/16 y, a continuación, se muestra el ID de la VPC.

En el ejemplo se crea una red virtual con 65 536 direcciones IP privadas.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2')

vpc = ec2.create_vpc({ cidr_block: '10.200.0.0/16' })

# So we get a public DNSvpc.modify_attribute({ enable_dns_support: { value: true }})

vpc.modify_attribute({ enable_dns_hostnames: { value: true }})

# Name our VPCvpc.create_tags({ tags: [{ key: 'Name', value: 'MyGroovyVPC' }]})

puts vpc.vpc_id

Creación de una gateway de Internet y su asociación auna VPCEn el siguiente ejemplo se crea una gateway de Internet MyGroovyIGW, se adjunta a una VPC con un IDVPC_ID y, a continuación, se muestra el ID de la gateway de Internet.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2')

igw = ec2.create_internet_gateway

igw.create_tags({ tags: [{ key: 'Name', value: 'MyGroovyIGW' }]})igw.attach_to_vpc(vpc_id: VPC_ID)

puts igw.id

Crear una subred públicaEn el siguiente ejemplo se crea una subred pública MyGroovySubnet en la región us-west-2 y la zonade disponibilidad us-west-2a. El ejemplo asocia la subred pública a una VPC con el ID VPC_ID queutiliza el bloque de CIDR 10.200.10.0/24 y, a continuación, muestra el ID de la subred.

La subred pública creada en este ejemplo tiene 256 direcciones IP privadas dentro de la VPC.

require 'aws-sdk'

34

Page 40: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una tabla de ruteo y su asociación a una subred

ec2 = Aws::EC2::Resource.new(region: 'us-west-2')

subnet = ec2.create_subnet({ vpc_id: VPC_ID, cidr_block: '10.200.10.0/24', availability_zone: 'us-west-2a'})

subnet.create_tags({ tags: [{ key: 'Name', value: 'MyGroovySubnet' }]})puts subnet.id

Creación de una tabla de ruteo y su asociación a unasubredEn el siguiente ejemplo se crea una tabla de ruteo MyGroovyRouteTable en la región us-west-2en una VPC con el ID VPC_ID. La tabla de ruteo utiliza la ruta con el bloque de CIDR 0.0.0.0/0 yla gateway con el ID IGW_ID. En el ejemplo se asocia la tabla de ruteo con la subred que tiene el IDSUBNET_ID y, a continuación, se muestra el ID de la tabla de ruteo.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2')

table = ec2.create_route_table({ vpc_id: VPC_ID })

table.create_tags({ tags: [{ key: 'Name', value: 'MyGroovyRouteTable' }]})

table.create_route({ destination_cidr_block: '0.0.0.0/0', gateway_id: IGW_ID})

table.associate_with_subnet({ subnet_id: SUBNET_ID})

puts table.id

Uso de direcciones IP elásticas en Amazon EC2Una dirección IP elástica es una dirección IP estática, diseñada para la informática en la nube dinámica,que está asociada a la cuenta de AWS. Se trata de una dirección IP pública a la que se puede obteneracceso desde Internet. Si la instancia no tiene una dirección IP pública, puede utilizar una dirección IPelástica con la instancia para que pueda comunicarse con Internet.

Para obtener más información acerca de las direcciones IP elásticas en Amazon EC2, consulteDirecciones IP elásticas en la Amazon EC2 User Guide for Linux Instances o Direcciones IP elásticas en laAmazon EC2 User Guide for Windows Instances.

En este ejemplo, va a utilizar AWS SDK for Ruby con Amazon EC2 para:

1. Asigne una dirección IP elástica mediante el método Aws::EC2::Client#allocate_address.2. Asocie la dirección a una instancia Amazon EC2 mediante el método

Aws::EC2::Client#associate_address.

35

Page 41: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideUso de direcciones IP elásticas en Amazon EC2

3. Obtenga información acerca de las direcciones asociadas a la instancia mediante el métodoAws::EC2::Client#describe_addresses.

4. Libere la dirección mediante el método Aws::EC2::Client#release_address.

El código completo de este ejemplo está disponible en GitHub.

Requisitos previosAntes de trabajar con el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También debe lanzar una instancia EC2 y anote el ID de instancia.

Note

Antes de ejecutar el siguiente código, debe reemplazar la cadena INSTANCE-ID por el ID deinstancia real. Tendrá un aspecto similar a i-0a123456b7c8defg9.

Script de ejemplorequire 'aws-sdk'

ec2 = Aws::EC2::Client.new(region: 'us-east-1')

instance_id = "INSTANCE-ID" # For example, "i-0a123456b7c8defg9"

def display_addresses(ec2, instance_id) describe_addresses_result = ec2.describe_addresses({ filters: [ { name: "instance-id", values: [ instance_id ] }, ] }) if describe_addresses_result.addresses.count == 0 puts "No addresses currently associated with the instance." else describe_addresses_result.addresses.each do |address| puts "=" * 10 puts "Allocation ID: #{address.allocation_id}" puts "Association ID: #{address.association_id}" puts "Instance ID: #{address.instance_id}" puts "Public IP: #{address.public_ip}" puts "Private IP Address: #{address.private_ip_address}" end endend

puts "Before allocating the address for the instance...."display_addresses(ec2, instance_id)

puts "\nAllocating the address for the instance..."allocate_address_result = ec2.allocate_address({ domain: "vpc" })

36

Page 42: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de un grupo de seguridad

puts "\nAfter allocating the address for instance, but before associating the address with the instance..."display_addresses(ec2, instance_id)

puts "\nAssociating the address with the instance..."associate_address_result = ec2.associate_address({ allocation_id: allocate_address_result.allocation_id, instance_id: instance_id, })

puts "\nAfter associating the address with the instance, but before releasing the address from the instance..."display_addresses(ec2, instance_id)

puts "\nReleasing the address from the instance..."ec2.release_address({ allocation_id: allocate_address_result.allocation_id, })

puts "\nAfter releasing the address from the instance..."display_addresses(ec2, instance_id)

Creación de un grupo de seguridadEn el siguiente ejemplo se crea un grupo de seguridad MyGroovySecurityGroup en la región us-west-2 en una VPC con el ID VPC_ID. En el ejemplo, el grupo de seguridad tiene permiso de acceso através del puerto 22 (SSH) desde todas las direcciones (bloque de CIDR 0.0.0.0/0) y se le asigna ladescripción "Grupo de seguridad para MyGroovyInstance". A continuación, se muestra el ID del grupo deseguridad.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2')

sg = ec2.create_security_group({ group_name: 'MyGroovySecurityGroup', description: 'Security group for MyGroovyInstance', vpc_id: VPC_ID })

sg.authorize_egress({ ip_permissions: [{ ip_protocol: 'tcp', from_port: 22, to_port: 22, ip_ranges: [{ cidr_ip: '0.0.0.0/0' }]})

puts sg.id

Trabajar con grupos de seguridad en Amazon EC2Un grupo de seguridad de Amazon EC2 funciona como un firewall virtual que controla el tráfico de una ovarias instancias. Se añaden reglas a cada grupo de seguridad para permitir el tráfico con sus instanciasasociadas. Puede modificar las reglas de un grupo de seguridad en cualquier momento: las nuevas reglasse aplican automáticamente a todas las instancias que están asociadas al grupo de seguridad.

Para obtener más información acerca de los grupos de seguridad de Amazon EC2, consulte:

37

Page 43: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTrabajar con grupos de seguridad en Amazon EC2

• Grupos de seguridad de Amazon EC2 para instancias de Linux• Grupos de seguridad de Amazon EC2 para instancias de Windows

En este ejemplo, vamos a utilizar AWS SDK for Ruby con Amazon EC2 para:

1. Crear un grupo de seguridad.2. Agregar reglas al grupo de seguridad.3. Obtener información sobre los grupos de seguridad.4. Eliminar el grupo de seguridad.

El script de muestra completo con todos los ejemplos siguientes está disponible en GitHub.

Requisitos previosAntes de trabajar con el código siguiente, debe instalar y configurar AWS SDK for Ruby. Consulte losiguiente:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También necesitará crear una VPC y anotar el ID de la VPC.

Configuración del SDKEn primer lugar necesitamos el SDK de AWS para Ruby y crear un cliente de EC2. A continuación,proporcionamos un nombre para el grupo de seguridad que vamos a crear. También es necesarioproporcionar el ID de la VPC, que se encuentra disponible en la consola una vez creada la VPC.Asegúrese de que sustituye "VPC-ID" con el ID real de la VPC.

require 'aws-sdk'

ec2 = Aws::EC2::Client.new(region: 'us-east-1')

security_group_name = "my-security-group"vpc_id = "VPC-ID" # For example, "vpc-1234ab56".security_group_created = false # Used later to determine whether it's okay to delete the security group.

Utilizaremos la security_group_created variable más adelante en el script para determinar si se hacreado un grupo de seguridad y, por lo tanto, se puede eliminar.

Creación de un grupo de seguridadA continuación, creamos un grupo de seguridad que permita el acceso a puertos 22 (SSH) y 80 (HTTP)desde todas las direcciones (bloque de CIDR 0.0.0.0/0).

# Create a security group.begin create_security_group_result = ec2.create_security_group({ group_name: security_group_name, description: "An example description for my security group.", vpc_id: vpc_id })

38

Page 44: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTrabajar con grupos de seguridad en Amazon EC2

# Add rules to the security group. # For example, allow all inbound HTTP and SSH traffic. ec2.authorize_security_group_ingress({ group_id: create_security_group_result.group_id, ip_permissions: [ { ip_protocol: "tcp", from_port: 80, to_port: 80, ip_ranges: [ { cidr_ip: "0.0.0.0/0", } ] }, { ip_protocol: "tcp", from_port: 22, to_port: 22, ip_ranges: [ { cidr_ip: "0.0.0.0/0", } ] } ] })

security_group_created = truerescue Aws::EC2::Errors::InvalidGroupDuplicate puts "A security group with the name '#{security_group_name}' already exists."end

Si el bloque begin se ejecuta sin excepciones, establecemos security_group_created en true.

Obtener información acerca de un grupo de seguridadDespués de crear un grupo de seguridad, ofrecemos la información sobre nuestros grupos de seguridadexistentes y sus permisos de IP.

def describe_ip_permission(ip_permission) puts "-" * 22 puts "IP Protocol: #{ip_permission.ip_protocol}" puts "From Port: #{ip_permission.from_port.to_s}" puts "To Port: #{ip_permission.to_port.to_s}" if ip_permission.ip_ranges.count > 0 puts "IP Ranges:" ip_permission.ip_ranges.each do |ip_range| puts " #{ip_range.cidr_ip}" end end if ip_permission.ipv_6_ranges.count > 0 puts "IPv6 Ranges:" ip_permission.ipv_6_ranges.each do |ipv_6_range| puts " #{ipv_6_range.cidr_ipv_6}" end end if ip_permission.prefix_list_ids.count > 0 puts "Prefix List IDs:" ip_permission.prefix_list_ids.each do |prefix_list_id| puts " #{prefix_list_id.prefix_list_id}" end end if ip_permission.user_id_group_pairs.count > 0

39

Page 45: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTrabajar con pares de claves

puts "User ID Group Pairs:" ip_permission.user_id_group_pairs.each do |user_id_group_pair| puts " ." * 7 puts " Group ID: #{user_id_group_pair.group_id}" puts " Group Name: #{user_id_group_pair.group_name}" puts " Peering Status: #{user_id_group_pair.peering_status}" puts " User ID: #{user_id_group_pair.user_id}" puts " VPC ID: #{user_id_group_pair.vpc_id}" puts " VPC Peering Connection ID: #{user_id_group_pair.vpc_peering_connection_id}" end endend

describe_security_groups_result = ec2.describe_security_groups

describe_security_groups_result.security_groups.each do |security_group| puts "\n" puts "*" * (security_group.group_name.length + 12) puts "Group Name: #{security_group.group_name}" puts "Group ID: #{security_group.group_id}" puts "Description: #{security_group.description}" puts "VPC ID: #{security_group.vpc_id}" puts "Owner ID: #{security_group.owner_id}" if security_group.ip_permissions.count > 0 puts "=" * 22 puts "IP Permissions:" security_group.ip_permissions.each do |ip_permission| describe_ip_permission(ip_permission) end end if security_group.ip_permissions_egress.count > 0 puts "=" * 22 puts "IP Permissions Egress:" security_group.ip_permissions_egress.each do |ip_permission| describe_ip_permission(ip_permission) end end if security_group.tags.count > 0 puts "=" * 22 puts "Tags:" security_group.tags.each do |tag| puts " #{tag.key} = #{tag.value}" end end end

Eliminación de un grupo de seguridadCuando finalice el script, y suponiendo que se ha creado un grupo de seguridad correctamente y que laetiqueta security_group_created se ha establecido en true, eliminamos el grupo de seguridad.

if security_group_created ec2.delete_security_group({ group_id: create_security_group_result.group_id })end

Trabajar con pares de clavesEn estos ejemplos se muestra cómo usar AWS SDK for Ruby con Amazon EC2 para:

• Cree un par de claves.• Obtener información sobre pares de claves.

40

Page 46: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTrabajar con pares de claves

• Eliminar un par de claves.

Para obtener más información acerca de los pares de claves, consulte Pares de claves Amazon EC2 en laAmazon EC2 User Guide for Linux Instances o Pares de claves Amazon EC2 e instancias de Windows enla Amazon EC2 User Guide for Windows Instances.

Para obtener código adicional que puede usar para ejecutar estos ejemplos, consulte Ejemplocompleto (p. 42).

Creación de un par de clavesLlame al método create_key_pair especificando el nombre del par de claves que va a crear.

key_pair = ec2.create_key_pair({ key_name: key_pair_name })

En este código:

• ec2 es una variable que representa un objeto Aws::EC2::Client.• key_pair_name es una variable de cadena que representa el nombre de un par de claves.• key_pair es una variable que representa un objeto Aws::EC2::KeyPair que devuelve la llamada al

método create_key_pair.

Para obtener más información, consulte Ejemplo completo (p. 42).

Obtener información sobre pares de clavesPara obtener información acerca de un único par de claves, utilice atributos como:

• key_name, que obtiene el nombre del par de claves.• key_fingerprint, que obtiene el resumen SHA-1 de la clave privada cifrada DER.• key_material, que obtiene la clave privada RSA cifrada de PEM no codificado.

puts "Created key pair '#{key_pair.key_name}'." puts "\nSHA-1 digest of the DER encoded private key:" puts "#{key_pair.key_fingerprint}" puts "\nUnencrypted PEM encoded RSA private key:" puts "#{key_pair.key_material}"

En este código, key_pair es una variable que representa un objeto Aws::EC2::KeyPair, que devuelve lallamada al método create_key_pair del ejemplo anterior.

Para obtener información sobre varios pares de claves, llame al método describe_key_pairs.

key_pairs_result = ec2.describe_key_pairs()

if key_pairs_result.key_pairs.count > 0 puts "\nKey pair names:" key_pairs_result.key_pairs.each do |key_pair| puts key_pair.key_name endend

41

Page 47: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTrabajar con pares de claves

En este código:

• ec2 es una variable que representa un objeto Aws::EC2::Client.• key_pair_result es una variable que representa un objeto

Aws::EC2::Types::DescribeKeyPairsResult que devuelve la llamada al método describe_key_pairs.• Llamar al método key_pairs del objeto Aws::EC2::Types::DescribeKeyPairsResult devuelve

una matriz de objetos Aws::EC2::Types::KeyPairInfo objetos que representan los pares de claves.

Para obtener más información, consulte Ejemplo completo (p. 42).

Eliminar un par de clavesLlame al método delete_key_pair especificando el nombre del par de claves que va a eliminar.

ec2.delete_key_pair({ key_name: key_pair_name })

En este código:

• ec2 es una variable que representa un objeto Aws::EC2::Client.• key_pair_name es una variable de cadena que representa el nombre de un par de claves.

Para obtener más información, consulte Ejemplo completo (p. 42).

Ejemplo completoEl siguiente código, que se puede adaptar y ejecutar, combina los ejemplos anteriores en un únicoejemplo.

require 'aws-sdk'

ec2 = Aws::EC2::Client.new(region: 'us-east-1')

key_pair_name = "my-key-pair"

# Create a key pair.begin key_pair = ec2.create_key_pair({ key_name: key_pair_name }) puts "Created key pair '#{key_pair.key_name}'." puts "\nSHA-1 digest of the DER encoded private key:" puts "#{key_pair.key_fingerprint}" puts "\nUnencrypted PEM encoded RSA private key:" puts "#{key_pair.key_material}"rescue Aws::EC2::Errors::InvalidKeyPairDuplicate puts "A key pair named '#{key_pair_name}' already exists."end

# Get information about Amazon EC2 key pairs.key_pairs_result = ec2.describe_key_pairs()

if key_pairs_result.key_pairs.count > 0 puts "\nKey pair names:" key_pairs_result.key_pairs.each do |key_pair| puts key_pair.key_name

42

Page 48: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información acerca de todas las instancias

endend

# Delete the key pair.ec2.delete_key_pair({ key_name: key_pair_name })

Para ejecutar este código, debe:

1. Instale AWS SDK for Ruby. Para obtener más información, consulte AWS SDK para Ruby (p. 4).2. Establezca las credenciales de acceso de AWS que utilizará el AWS SDK for Ruby para verificar

el acceso a los servicios y recursos de AWS. Para obtener más información, consulte Configuringthe AWS SDK for Ruby (p. 5). Asegúrese de que las credenciales de AWS están asignadas a unaentidad AWS Identity and Access Management (IAM) con acceso a los recursos y acciones de AWSdescritos en este ejemplo. En este ejemplo se supone que ha establecido las credenciales en elarchivo del perfil de credenciales de AWS o en las variables de entorno AWS_ACCESS_KEY_ID yAWS_SECRET_ACCESS_KEY del sistema local.

Obtener información acerca de todas las instanciasEn el siguiente ejemplo se muestran los ID y los estados (pending, running, shutting down, terminated,stopping o stopped) de todas las instancias Amazon EC2 en la región us-west-2.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2') # To only get the first 10 instances:# ec2.instances.limit(10).each do |i|ec2.instances.each do |i| puts "ID: #{i.id}" puts "State: #{i.state.name}"end

Obtener información acerca de todas las instanciascon un valor de etiqueta específicoEn el siguiente ejemplo se muestra el ID y estado (pending, running, shutting down, terminated, stopping ostopped) de una instancia Amazon EC2 con la etiqueta Group y valor de etiqueta MyGroovyGroup en laregión us-west-2.

Note

Los valores y nombres de las etiquetas distinguen entre mayúsculas y minúsculas.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2')

# Get all instances with tag key 'Group'# and tag value 'MyGroovyGroup':ec2.instances({filters: [{name: 'tag:Group', values: ['MyGroovyGroup']}]}).each do |i| puts 'ID: ' + i.id puts 'State: ' + i.state.nameend

43

Page 49: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información acerca de una instancia específica

Obtener información acerca de una instanciaespecíficaEn el siguiente ejemplo se muestra el estado de una instancia i-123abc en la región us-west-2.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2') i = ec2.instance('i-123abc')

if i.exists? puts "State: #{i.state.name}"end

Creación de una instanciaEn el siguiente ejemplo se crea una instancia de Amazon EC2 MyGroovyInstance, con la etiquetaGroup y el valor MyGroovyGroup. La instancia se crea en la zona de disponibilidad us-west-2a conla imagen de máquina MACHINE_IMAGE para la cuenta con el ID ACCOUNT_ID, el grupo de seguridadcon el ID SECURITY_GROUP_ID y la subred con el ID SUBNET_ID. A continuación, se muestran el ID y ladirección IP pública de la instancia.

Note

En el valor de script vacío, puede añadir las instrucciones que ejecuta la instancia Amazon EC2cuando se inicia.

require 'aws-sdk'require 'base64'

# User code that's executed when the instance startsscript = ''

encoded_script = Base64.encode64(script)

ec2 = Aws::EC2::Resource.new(region: 'us-west-2')

instance = ec2.create_instances({ image_id: 'IMAGE_ID', min_count: 1, max_count: 1, key_name: 'MyGroovyKeyPair', security_group_ids: ['SECURITY_GROUP_ID'], user_data: encoded_script, instance_type: 't2.micro', placement: { availability_zone: 'us-west-2a' }, subnet_id: 'SUBNET_ID', iam_instance_profile: { arn: 'arn:aws:iam::' + 'ACCOUNT_ID' + ':instance-profile/aws-opsworks-ec2-role' }})

# Wait for the instance to be created, running, and passed status checksec2.client.wait_until(:instance_status_ok, {instance_ids: [instance[0].id]})

# Name the instance 'MyGroovyInstance' and give it the Group tag 'MyGroovyGroup'

44

Page 50: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideParada de una instancia

instance.create_tags({ tags: [{ key: 'Name', value: 'MyGroovyInstance' }, { key: 'Group', value: 'MyGroovyGroup' }]})

puts instance.idputs instance.public_ip_address

Parada de una instanciaEn el siguiente ejemplo, la instancia i-123abc se detiene en la región us-west-2.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2') i = ec2.instance('i-123abc') if i.exists? case i.state.code when 48 # terminated puts "#{id} is terminated, so you cannot stop it" when 64 # stopping puts "#{id} is stopping, so it will be stopped in a bit" when 89 # stopped puts "#{id} is already stopped" else i.stop endend

Iniciar una instanciaEn el siguiente ejemplo, la instancia i-123abc se inicia en la región us-west-2.

require 'aws-sdk'

ec2 = Aws::EC2::Resource.new(region: 'us-west-2') i = ec2.instance('i-123abc') if i.exists? case i.state.code when 0 # pending puts "#{id} is pending, so it will be running in a bit" when 16 # started puts "#{id} is already started" when 48 # terminated puts "#{id} is terminated, so you cannot start it" else i.start endend

Reinicio de una instanciaEn el siguiente ejemplo, la instancia i-123abc se reinicia en la región us-west-2.

require 'aws-sdk'

45

Page 51: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministración de instancias Amazon EC2 en Amazon EC2

ec2 = Aws::EC2::Resource.new(region: 'us-west-2') i = ec2.instance('i-123abc') if i.exists? case i.state.code when 48 # terminated puts "#{id} is terminated, so you cannot reboot it" else i.reboot endend

Administración de instancias Amazon EC2 en AmazonEC2En este ejemplo, va a utilizar AWS SDK for Ruby con Amazon EC2 para:

1. Detener una instancia Amazon EC2 existente con Aws::EC2::Client#stop_instances.2. Reiniciar la instancia con Aws::EC2::Client#start_instances.3. Reiniciar la instancia con Aws::EC2::Client#reboot_instances.4. Habilitar la monitorización detallada de la instancia con Aws::EC2::Client#monitor_instances.5. Obtener información acerca de las instancias disponibles con Aws::EC2::Client#describe_instances.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También debe reemplazar INSTANCE-ID en el código con el ID de instancia de una instancia EC2.

Ejemplo

require 'aws-sdk'

# Uncomment for Windows.# Aws.use_bundled_cert!

def wait_for_instances(ec2, state, ids) begin ec2.wait_until(state, instance_ids: ids) puts "Success: #{state}." rescue Aws::Waiters::Errors::WaiterFailed => error puts "Failed: #{error.message}" endend

ec2 = Aws::EC2::Client.new(region: 'us-east-1')

instance_id = "INSTANCE-ID" # For example, "i-0a123456b7c8defg9"

puts "Attempting to stop instance '#{instance_id}'. This may take a few minutes..."

46

Page 52: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTerminación de una instancia

ec2.stop_instances({ instance_ids: [instance_id] })wait_for_instances(ec2, :instance_stopped, [instance_id])

puts "\nAttempting to restart instance '#{instance_id}'. This may take a few minutes..."ec2.start_instances({ instance_ids: [instance_id] })wait_for_instances(ec2, :instance_running, [instance_id])

puts "\nAttempting to reboot instance '#{instance_id}'. This may take a few minutes..."ec2.reboot_instances({ instance_ids: [instance_id] })wait_for_instances(ec2, :instance_status_ok, [instance_id])

# Enable detailed monitoring for the instance.puts "\nAttempting to enable detailed monitoring for instance '#{instance_id}'..."

begin monitor_instances_result = ec2.monitor_instances({ instance_ids: [instance_id] }) puts "Detailed monitoring state for instance '#{instance_id}': #{monitor_instances_result.instance_monitorings[0].monitoring.state}"rescue Aws::EC2::Errors::InvalidState puts "Instance '#{instance_id}' is not in a monitorable state. Continuing on..."end

# Get information about available instances.puts "\nAvailable instances:"

describe_instances_result = ec2.describe_instances

describe_instances_result.reservations.each do |reservation| if reservation.instances.count > 0 reservation.instances.each do |instance| puts "=" * (instance.instance_id.length + 13) puts "Instance ID: #{instance.instance_id}" puts "State: #{instance.state.name}" puts "Image ID: #{instance.image_id}" puts "Instance Type: #{instance.instance_type}" puts "Architecure: #{instance.architecture}" puts "IAM Instance Profile: #{instance.iam_instance_profile}" puts "Key Name: #{instance.key_name}" puts "Launch Time: #{instance.launch_time}" puts "Detailed Monitoring State: #{instance.monitoring.state}" puts "Public IP Address: #{instance.public_ip_address}" puts "Public DNS Name: #{instance.public_dns_name}" puts "VPC ID: #{instance.vpc_id}" puts "Subnet ID: #{instance.subnet_id}" if instance.tags.count > 0 puts "Tags:" instance.tags.each do |tag| puts " #{tag.key} = #{tag.value}" end end end end

end

Terminación de una instanciaEn el siguiente ejemplo, se termina la instancia i-123abc en la región us-west-2.

require 'aws-sdk'

47

Page 53: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información sobre las

regiones y las zonas de disponibilidad

ec2 = Aws::EC2::Resource.new(region: 'us-west-2') i = ec2.instance('i-123abc') if i.exists? case i.state.code when 48 # terminated puts "#{id} is already terminated" else i.terminate endend

Obtener información sobre las regiones y las zonas dedisponibilidadEn estos ejemplos se muestra cómo usar AWS SDK for Ruby con Amazon EC2 para:

• Obtener información sobre las regiones de Amazon EC2 disponibles y sus puntos de conexión.• Obtener información sobre las zonas de disponibilidad de Amazon EC2.

Para obtener más información sobre regiones de Amazon EC2 y zonas de disponibilidad, consulteRegiones y zonas de disponibilidad en la Amazon EC2 User Guide for Linux Instances.

Para obtener código adicional que puede usar para ejecutar estos ejemplos, consulte Ejemplocompleto (p. 49).

Obtener más información sobre regiones y puntos de conexión.Para obtener información sobre las regiones disponibles, llame al método describe_regions.

describe_regions_result = ec2.describe_regions()

En este código, ec2 es una variable que representa un objeto Aws::EC2::Client. Para obtener másinformación, consulte Ejemplo completo (p. 49).

Para obtener los nombres de las regiones y los puntos de conexión:

1. Obtenga un objeto Aws::EC2::Types::DescribeRegionsResult, que devuelve el métododescribe_regions y está representado en este código por la variable describe_regions_result.

2. Utilice el atributo regions del objeto DescribeRegionsResult para obtener una matriz de objetosAws::EC2::Types::Region que representan las regiones.

3. Obtenga el nombre y el punto de conexión de cada región usando los atributos region_name y endpointdel objeto Region.

describe_regions_result.regions.each do |region| puts "#{region.region_name} (#{region.endpoint})" end

Obtener información acerca de las zonas de disponibilidadPara obtener información acerca de las zonas de disponibilidad, llame al métododescribe_availability_zones.

48

Page 54: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información sobre las

regiones y las zonas de disponibilidad

describe_availability_zones_result = ec2.describe_availability_zones()

El objeto Aws::EC2::Types::DescribeAvailabilityZonesResult contiene una matriz de objetosAws::EC2::Types::AvailabilityZone que representan las zonas de disponibilidad. El métododescribe_availability_zones devuelve el objeto DescribeAvailabilityZonesResult y eneste código está representado por la variable describe_availability_zones_result.

En este código, ec2 es una variable que representa un objeto Aws::EC2::Client. Para obtener másinformación, consulte Ejemplo completo (p. 49).

Para obtener el nombre y el estado de cada zona de disponibilidad, utilice los atributos zone_name y statedel objeto AvailabilityZone.

describe_availability_zones_result.availability_zones.each do |zone| puts "#{zone.zone_name} is #{zone.state}" if zone.messages.count > 0 zone.messages.each do |message| " #{message.message}" end endend

Para obtener mensajes sobre las zonas de disponibilidad:

1. Use el atributo messages del objeto AvailabilityZone, que devuelve una matrizAws::EC2::Types::AvailabilityZoneMessage.

2. Si la matriz contiene al menos un mensaje, utilice el atributo message del objetoAvailabilityZoneMessage para obtenerlo.

Ejemplo completoEl siguiente código, que se puede adaptar y ejecutar, combina los ejemplos anteriores en un únicoejemplo.

require 'aws-sdk'

ec2 = Aws::EC2::Client.new(region: 'us-east-1')

puts "Amazon EC2 region(s) (and their endpoint(s)) that are currently available to you:\n\n"describe_regions_result = ec2.describe_regions()

describe_regions_result.regions.each do |region| puts "#{region.region_name} (#{region.endpoint})" end

puts "\nAmazon EC2 availability zone(s) that are available to you for your current region:\n\n"describe_availability_zones_result = ec2.describe_availability_zones()

describe_availability_zones_result.availability_zones.each do |zone| puts "#{zone.zone_name} is #{zone.state}" if zone.messages.count > 0 zone.messages.each do |message| " #{message.message}" end endend

49

Page 55: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de AWS Elastic Beanstalk

Para ejecutar este código:

1. Instale AWS SDK for Ruby. Para obtener más información, consulte AWS SDK para Ruby (p. 4).2. Establezca las credenciales de acceso de AWS que utilizará el AWS SDK for Ruby para verificar

el acceso a los servicios y recursos de AWS. Para obtener más información, consulte Configuringthe AWS SDK for Ruby (p. 5). Asegúrese de que las credenciales de AWS están asignadas a unaentidad AWS Identity and Access Management (IAM) con acceso a los recursos y acciones de AWSdescritos en este ejemplo. En este ejemplo se supone que ha establecido las credenciales en elarchivo del perfil de credenciales de AWS o en las variables de entorno AWS_ACCESS_KEY_ID yAWS_SECRET_ACCESS_KEY del sistema local.

Ejemplos de AWS Elastic BeanstalkPuede utilizar los siguientes ejemplos para acceder a AWS Elastic Beanstalk (Elastic Beanstalk) medianteAWS SDK for Ruby. Para obtener más información acerca de Elastic Beanstalk, consulte la Guía paradesarrolladores de Elastic Beanstalk.

Ejemplos

Temas• Obtener información acerca de todas las aplicaciones (p. 50)• Obtener información acerca de una aplicación específica (p. 50)• Actualización de una aplicación Ruby on Rails (p. 51)

Obtener información acerca de todas las aplicacionesEn el siguiente ejemplo se muestran los nombres, las descripciones y las URL de todas las aplicaciones deElastic Beanstalk en la región us-west-2.

require 'aws-sdk'

elb = Aws::ElasticBeanstalk::Client.new(region: 'us-west-2') elb.describe_applications.applications.each do |a| puts "Name: #{a.application_name}" puts "Description: #{a.description}"

elb.describe_environments({application_name: a.application_name}).environments.each do |env| puts " Environment: #{env.environment_name}" puts " URL: #{env.cname}" puts " Health: #{env.health}" endend

Obtener información acerca de una aplicaciónespecíficaEn el siguiente ejemplo se muestran el nombre, la descripción y la URL de la aplicación MyRailsApp en laregión us-west-2.

require 'aws-sdk'

50

Page 56: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideActualización de una aplicación Ruby on Rails

elb = Aws::ElasticBeanstalk::Client.new(region: 'us-west-2') app = elb.describe_applications({application_names: [args[0]]})

if app.exists? puts "Name: #{app.application_name}" puts "Description: #{app.description}"

envs = elb.describe_environments({application_name: app.application_name}) puts "URL: #{envs.environments[0].cname}"end

Actualización de una aplicación Ruby on RailsEn el siguiente ejemplo se actualiza la aplicación Ruby on Rails MyRailsApp en la región us-west-2.

Note

Debe situarse en la raíz de la aplicación Rails para ejecutar correctamente el script.

require 'aws-sdk'

Aws.config.update({region: 'us-west-2'})

elb = Aws::ElasticBeanstalk::Client.news3 = Aws::S3::Client.new

app_name = 'MyRailsApp'

# Get S3 bucket containing appapp_versions = elb.describe_application_versions({ application_name: app_name })av = app_versions.application_versions[0]bucket = av.source_bundle.s3_buckets3_key = av.source_bundle.s3_key

# Get info on environmentenvs = elb.describe_environments({ application_name: app_name })env = envs.environments[0]env_name = env.environment_name

# Create new storage locationresp = elb.create_storage_location()

puts "Created storage location in bucket #{resp.s3_bucket}"

resp = s3.list_objects({ prefix: s3_key, bucket: bucket})

# Create ZIP filezip_file_basename = SecureRandom.urlsafe_base64.to_szip_file_name = zip_file_basename + '.zip'

# Call out to OS to produce ZIP filecmd = "git archive --format=zip -o #{zip_file_name} HEAD"%x[ #{cmd} ]

# Get ZIP file contentszip_contents = File.read(zip_file_name)

key = app_name + "\\" + zip_file_name

51

Page 57: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de AWS Identity and Access Management

resp = s3.put_object({ body: zip_contents, bucket: bucket, key: key})

date = Time.newtoday = date.day.to_s + "/" + date.month.to_s + "/" + date.year.to_s

elb.create_application_version({ process: false, application_name: app_name, version_label: zip_file_basename, source_bundle: { s3_bucket: bucket, s3_key: key }, description: "Updated #{today}"})

elb.update_environment({ environment_name: env_name, version_label: zip_file_basename})

Ejemplos de AWS Identity and Access ManagementPuede utilizar los siguientes ejemplos para acceder a AWS Identity and Access Management (IAM)mediante AWS SDK for Ruby. Para obtener más información acerca de IAM, consulte la documentación deIAM.

Ejemplos

Temas• Obtener información sobre todos los usuarios (p. 52)• Añadir un usuario nuevo (p. 53)• Creación de las claves de acceso de un usuario (p. 53)• Agregar una política administrada (p. 54)• Creación de un rol (p. 54)• Administración de usuarios de IAM (p. 55)• Trabajar con políticas de IAM (p. 56)• Administración de las claves de acceso de IAM (p. 57)• Uso de certificados de servidor de IAM (p. 59)• Administración de alias de cuenta de IAM (p. 60)

Obtener información sobre todos los usuariosEn el siguiente ejemplo se muestra una lista de los grupos, las políticas y los ID de clave de acceso detodos los usuarios de IAM en la región us-west-2.

require 'aws-sdk'

iam = Aws::IAM::Client.new(region: 'us-west-2')

52

Page 58: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAñadir un usuario nuevo

iam.list_users.users.each do |user| name = user.user_name puts "For user #{name}" puts " In groups:" iam.list_groups_for_user({user_name: name}).groups.each do |group| puts " #{group.group_name}" end puts " Policies:" iam.list_user_policies({user_name: name}).policy_names.each do |policy| puts " #{policy}" end puts " Access keys:" iam.list_access_keys({user_name: name}).access_key_metadata.each do |key| puts " #{key.access_key_id}" endend

Añadir un usuario nuevoEn el siguiente ejemplo se crea el usuario de IAM my_groovy_user en la región us-west-2 con lacontraseña REPLACE_ME y se muestra el ID de la cuenta del usuario. Si ya existe un usuario con esenombre, se muestra un mensaje y no se crea un nuevo usuario.

require 'aws-sdk'

iam = Aws::IAM::Client.new(region: 'us-west-2')

begin user = iam.create_user(user_name: 'my_groovy_user') iam.wait_until(:user_exists, user_name: 'my_groovy_user')

user.create_login_profile({password: 'REPLACE_ME'})

arn_parts = user.arn.split(':') puts 'Account ID: ' + arn_parts[4]rescue Aws::IAM::Errors::EntityAlreadyExists puts 'User already exists'end

Creación de las claves de acceso de un usuarioEn el siguiente ejemplo se crea una clave de acceso y una clave secreta para el usuario de IAMmy_groovy_user en la región us-west-2.

require 'aws-sdk'

iam = Aws::IAM::Client.new(region: 'us-west-2')

begin user = iam.user(user_name: 'my_groovy_user')

key_pair = user.create_access_key_pair

puts "Access key: #{key_pair.access_key_id}" puts "Secret key: #{key_pair.secret}"rescue Aws::IAM::Errors::NoSuchEntity => ex

53

Page 59: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAgregar una política administrada

puts 'User does not exist'end

Agregar una política administradaEn el siguiente ejemplo se añade la política administrada AmazonS3FullAccess al usuario de IAMmy_groovy_user en la región us-west-2.

require 'aws-sdk'

# Policy ARNs start with:prefix = 'arn:aws:iam::aws:policy/'

policy_arn = prefix + 'AmazonS3FullAccess'

# In case the policy or user does not existbegin client.attach_user_policy({user_name: 'my_groovy_user', policy_arn: policy_arn})rescue Aws::IAM::Errors::NoSuchEntity => ex puts "Error attaching policy '#{policy_arn}'" puts ex.messageend

Creación de un rolEn el siguiente ejemplo se crea el rol my_groovy_role para que Amazon EC2 pueda acceder a AmazonS3 y Amazon DynamoDB en la región us-west-2.

require 'aws-sdk'

client = Aws::IAM::Client.new(region: 'us-west-2')iam = Aws::IAM::Resource.new(client: client)

# Let EC2 assume a rolepolicy_doc = { Version:"2012-10-17", Statement:[ { Effect:"Allow", Principal:{ Service:"ec2.amazonaws.com" }, Action:"sts:AssumeRole" }]}

role = iam.create_role({ role_name: 'my_groovy_role', assume_role_policy_document: policy_doc.to_json})

# Give the role full access to S3role.attach_policy({ policy_arn: 'arn:aws:iam::aws:policy/AmazonS3FullAccess'})

# Give the role full access to DynamoDBrole.attach_policy({ policy_arn: 'arn:aws:iam::aws:policy/AmazonDynamoDBFullAccess'})

54

Page 60: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministración de usuarios de IAM

Administración de usuarios de IAMUn usuario de IAM representa a la persona o el servicio que interactúa con AWS. Para obtener másinformación acerca de los usuarios de IAM, consulte Usuarios de IAM.

En este ejemplo, va a utilizar AWS SDK for Ruby con IAM para:

1. Puede obtener información acerca de los usuarios de AWS IAM disponibles medianteAws::IAM::Client#list_users.

2. Cree un usuario mediante Aws::IAM::Client#create_user.3. Actualice el nombre del usuario mediante Aws::IAM::Client#update_user.4. Elimine el usuario mediante Aws::IAM::Client#delete_user.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

Ejemplorequire 'aws-sdk'

iam = Aws::IAM::Client.new(region: 'us-east-1')

user_name = "my-user"changed_user_name = "my-changed-user"

# Get information about available AWS IAM users.def list_user_names(iam) list_users_response = iam.list_users list_users_response.users.each do |user| puts user.user_name endend

puts "User names before creating user..."list_user_names(iam)

# Create a user.puts "\nCreating user..."

iam.create_user({ user_name: user_name })

puts "\nUser names after creating user..."list_user_names(iam)

# Update the user's name.puts "\nChanging user's name..."

begin iam.update_user({ user_name: user_name, new_user_name: changed_user_name })

55

Page 61: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTrabajar con políticas de IAM

puts "\nUser names after updating user's name..." list_user_names(iam)rescue Aws::IAM::Errors::EntityAlreadyExists puts "User '#{user_name}' already exists."end

# Delete the user.puts "\nDeleting user..."iam.delete_user({ user_name: changed_user_name })

puts "\nUser names after deleting user..."list_user_names(iam)

Trabajar con políticas de IAMUna política de IAM es un documento que especifica uno o varios permisos. Para obtener más informaciónsobre las políticas de IAM, consulte Descripción general de políticas de IAM.

En este ejemplo, va a utilizar AWS SDK for Ruby con IAM para:

1. Crear una política utilizando Aws::IAM::Client#create_policy.2. Obtener información sobre la política utilizando Aws::IAM::Client#get_policy.3. Adjuntar la política a un rol usando Aws::IAM::Client#attach_role_policy.4. Mostar las políticas adjuntas al rol usando Aws::IAM::Client#list_attached_role_policies.5. Separar la política del rol usando Aws::IAM::Client#detach_role_policy.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También es necesario crear el rol (my-role) especificado en el script. Puede hacerlo en la consola de IAM.

Ejemplorequire 'aws-sdk'

iam = Aws::IAM::Client.new(region: 'us-east-1')

role_name = "my-role"policy_name = "my-policy"policy_document = { "Version" => "2012-10-17", "Statement" => [ { "Effect" => "Allow", "Action" => "s3:ListAllMyBuckets", "Resource" => "arn:aws:s3:::*" } ]}.to_json

# Create a policy.puts "Creating policy..."

56

Page 62: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministración de las claves de acceso de IAM

create_policy_response = iam.create_policy({ policy_name: policy_name, policy_document: policy_document})

policy_arn = create_policy_response.policy.arn

# Get information about the policy.get_policy_response = iam.get_policy({ policy_arn: policy_arn })

puts "\nCreated policy, ID = #{get_policy_response.policy.policy_id}"

# Attach the policy to a role.puts "\nAttaching policy to role..." iam.attach_role_policy({ role_name: role_name, policy_arn: policy_arn}) # List policies attached to the role.puts "\nAttached role policy ARNs..."

iam.list_attached_role_policies({ role_name: role_name }).attached_policies.each do |attached_policy| puts " #{attached_policy.policy_arn}"end

# Detach the policy from the role.puts "\nDetaching role policy..."

iam.detach_role_policy({ role_name: role_name, policy_arn: policy_arn})

Administración de las claves de acceso de IAMLos usuarios necesitan sus propias claves de acceso para realizar llamadas programáticas a AWS desdeSDK para Ruby. Para atender esta necesidad, puede crear, modificar, ver o rotar claves de acceso (ID declave de acceso y claves de acceso secretas) de los usuarios de IAM. De manera predeterminada, cuandocrea una clave de acceso, su estado es Active, lo que significa que el usuario puede utilizar la clave deacceso para realizar llamadas al API. Para obtener más información acerca de las claves de acceso,consulte Administración de las claves de acceso de los usuarios de IAM.

En este ejemplo, va a utilizar AWS SDK for Ruby con IAM para:

1. Muestre las claves de acceso de los usuarios de AWS IAM mediante Aws::IAM::Client#list_access_keys.2. Cree una clave de acceso mediante Aws::IAM::Client#create_access_key.3. Determine cuándo se han utilizado por última vez las claves de acceso mediante

Aws::IAM::Client#get_access_key_last_used.4. Desactive las claves de acceso mediante Aws::IAM::Client#update_access_key.5. Elimine la clave de acceso mediante Aws::IAM::Client#delete_access_key.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

57

Page 63: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministración de las claves de acceso de IAM

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También debe crear el usuario (my-user) especificado en el script. Puede crear un nuevo usuariode IAM en la consola de IAM o de forma programada, tal y como se muestra en Añadir un nuevousuario (p. 53).

Ejemplorequire 'aws-sdk'

iam = Aws::IAM::Client.new(region: 'us-east-1')

user_name = "my-user"

# List user access keys.def list_keys(iam, user_name) begin list_access_keys_response = iam.list_access_keys({ user_name: user_name })

if list_access_keys_response.access_key_metadata.count == 0 puts "No access keys." else puts "Access keys:" list_access_keys_response.access_key_metadata.each do |key_metadata| puts " Access key ID: #{key_metadata.access_key_id}" end end rescue Aws::IAM::Errors::NoSuchEntity puts "Cannot find user '#{user_name}'." exit(false) end end

puts "Before creating access key..."list_keys(iam, user_name)

# Create an access key.puts "\nCreating access key..."

begin iam.create_access_key({ user_name: user_name }) puts "\nAfter creating access key..." list_keys(iam, user_name)rescue Aws::IAM::Errors::LimitExceeded puts "Too many access keys. Can't create any more."end

# Determine when access keys were last used.puts "\nKey(s) were last used..."

list_access_keys_response = iam.list_access_keys({ user_name: user_name })

list_access_keys_response.access_key_metadata.each do |key_metadata| resp = iam.get_access_key_last_used({ access_key_id: key_metadata.access_key_id }) puts " Key '#{key_metadata.access_key_id}' last used on #{resp.access_key_last_used.last_used_date}"

# Deactivate access keys. puts " Trying to deactivate this key..."

58

Page 64: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideUso de certificados de servidor de IAM

iam.update_access_key({ user_name: user_name, access_key_id: key_metadata.access_key_id, status: "Inactive" })end

puts "\nAfter deactivating access key(s)..."list_keys(iam, user_name)

# Delete the access key.puts "\nDeleting access key..."

iam.delete_access_key({ user_name: user_name, access_key_id: list_access_keys_response.access_key_metadata[0].access_key_id})

puts "\nAfter deleting access key..."list_keys(iam, user_name)

Uso de certificados de servidor de IAMPara habilitar las conexiones HTTPS en su sitio web o aplicación en AWS, necesita un certificado deservidor de SSL/TLS. Para utilizar un certificado obtenido de un proveedor externo con su sitio web oaplicación en AWS, debe cargar el certificado en IAM o importarlo a AWS Certificate Manager. Paraobtener más información acerca de los certificados de servidor, consulte Uso de certificados de servidor.

En este ejemplo, va a utilizar AWS SDK for Ruby con IAM para:

1. Actualice un certificado de servidor mediante Aws::IAM::Client#update_server_certificate.2. Elimine el certificado de servidor mediante Aws::IAM::Client#delete_server_certificate.3. Muestre información acerca de los certificados de servidor restante mediante

Aws::IAM::Client#list_server_certificates.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

Cabe señalar también que el certificado de servidor ya debe existir, de lo contrario el script producirá unerror Aws::IAM::Errores::NoSuchEntity.

Ejemplorequire 'aws-sdk'

iam = Aws::IAM::Client.new(region: 'us-east-1')

server_certificate_name = "my-server-certificate"changed_server_certificate_name = "my-changed-server-certificate"

# Update a server certificate.iam.update_server_certificate({

59

Page 65: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministración de alias de cuenta de IAM

server_certificate_name: server_certificate_name, new_server_certificate_name: changed_server_certificate_name})

# Delete the server certificate.iam.delete_server_certificate({ server_certificate_name: changed_server_certificate_name})

# List information about any remaining server certificates.list_server_certificates_response = iam.list_server_certificates

if list_server_certificates_response.server_certificate_metadata_list.count == 0 puts "No server certificates."else list_server_certificates_response.server_certificate_metadata_list.each do |certificate_metadata| puts "-" * certificate_metadata.server_certificate_name.length puts "Name: #{certificate_metadata.server_certificate_name}"

get_server_certificate_response = iam.get_server_certificate({ server_certificate_name: "certificate_metadata.server_certificate_name" }) puts "ID: #{get_server_certificate_response.server_certificate.server_certificate_metadata.server_certificate_id}" endend

Administración de alias de cuenta de IAMSi quiere que la dirección URL de la página de inicio de sesión contenga el nombre de su empresa u otroidentificador intuitivo en lugar de su ID de cuenta de AWS, puede crear un alias para el ID de cuenta deAWS. Si crea un alias de cuenta de AWS, la dirección URL de su página de inicio de sesión cambia paraincorporar dicho alias. Para obtener más información sobre alias de cuentas de IAM, consulte Su ID decuenta y alias de AWS.

En este ejemplo, va a utilizar AWS SDK for Ruby con IAM para:

1. Mostrar una lista de alias de la cuenta de AWS, utilizando Aws::IAM::Client#list_account_aliases.2. Crear un alias de cuenta, utilizando Aws::IAM::Client#create_account_alias.3. Eliminar el alias de cuenta, utilizando Aws::IAM::Client#delete_account_alias.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

En el código de ejemplo, cambie la cadena my-account-alias por algo único para todos los productos deAmazon Web Services.

Ejemplorequire 'aws-sdk'

60

Page 66: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de Lambda

iam = Aws::IAM::Client.new(region: 'us-east-1')

account_alias = "my-account-alias"

# List account aliases.def list_aliases(iam) list_account_aliases_response = iam.list_account_aliases

if list_account_aliases_response.account_aliases.count == 0 puts "No account aliases." else puts "Aliases:" list_account_aliases_response.account_aliases.each do |account_alias| puts account_alias end end

end

puts "Before creating account alias..."list_aliases(iam)

# Create an account alias.puts "\nCreating account alias..."iam.create_account_alias({ account_alias: account_alias })

puts "\nAfter creating account alias..."list_aliases(iam)

# Delete the account alias.puts "\nDeleting account alias..."iam.delete_account_alias({ account_alias: account_alias })

puts "\nAfter deleting account alias..."list_aliases(iam)

Ejemplos de LambdaPuede utilizar los siguientes ejemplos para acceder a AWS Lambda (Lambda) mediante AWS SDK forRuby. Para obtener más información acerca de Lambda, consulte la documentación de Lambda.

Ejemplos

Temas• Visualización de información acerca de todas las funciones de Lambda (p. 61)• Creación de una función de Lambda (p. 62)• Ejecución de una función de Lambda (p. 62)• Configuración de una función de Lambda para recibir notificaciones (p. 64)

Visualización de información acerca de todas lasfunciones de LambdaEn el siguiente ejemplo se muestran el nombre, el ARN y el rol de todas las funciones de Lambda en laregión us-west-2.

require 'aws-sdk'

61

Page 67: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una función de Lambda

client = Aws::Lambda::Client.new(region: 'us-west-2')

client.list_functions.each do |function| puts 'Name: ' + function.function_name puts 'ARN: ' + function.function_arn puts 'Role: ' + function.role

Creación de una función de LambdaEn el siguiente ejemplo se crea la función de Lambda my-notification-function en la región us-west-2 mediante estos valores:

• ARN de rol: my-resource-arn. En la mayoría de los casos, solo debe adjuntar la política administradaAWSLambdaExecute a la política de este rol.

• Punto de entrada de la función: my-package.my-class• Tiempo de ejecución: java8• Archivo zip: my-zip-file.zip• Bucket: my-notification-bucket• Key: my-zip-file

require 'aws-sdk'

client = Aws::Lambda::Client.new(region: 'us-west-2')

args = {}args[:role] = 'my-resource-arn'args[:function_name] = 'my-notification-function'args[:handler] = 'my-package.my-class'

# Also accepts nodejs, nodejs4.3, and python2.7args[:runtime] = 'java8'

code = {}code[:zip_file] = 'my-zip-file.zip'code[:s3_bucket] = 'my-notification-bucket'code[:s3_key] = 'my-zip-file'

args[:code] = code

client.create_function(args)

Ejecución de una función de LambdaEn el siguiente ejemplo, la función MyGetitemsFunction de Lambda se ejecuta en la región us-west-2. Esta función devuelve una lista de elementos de una base de datos. El JSON de entrada tieneeste aspecto:

{ "SortBy": "name|time", "SortOrder": "ascending|descending", "Number": 50}

donde:

62

Page 68: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjecución de una función de Lambda

• SortBy son los criterios para ordenar los resultados. En nuestros ejemplos se utiliza time, lo quesignifica que los elementos devueltos se ordenan en el orden en que se han añadido a la base de datos.

• SortOrder es el criterio de ordenación. En nuestro ejemplo se utiliza descending, lo que significa queel elemento más reciente es el último de la lista.

• Number es el número máximo de elementos que se recuperan (el valor predeterminado es 50). Ennuestro ejemplo se utiliza 10, lo que significa que se obtienen los 10 elementos más recientes.

El JSON de salida tiene este aspecto:

{ "statusCode": 200|..., "body": { "result": "'success' or 'failure'", "error": "Error message if 'failure', '' otherwise" "data": [{"item1"}, ..., {"itemN"}] }}

donde:

• statusCode es un código de estado HTTP, 200 significa que la llamada se ha realizado correctamente.• body es el cuerpo del JSON que se devuelve.• result es el resultado de la llamada, ya sea success o failure.• error es un mensaje de error si result es failure, de lo contrario se devuelve una cadena vacía.• data son los resultados que se devuelven si result es success, de lo contrario se devuelve el valor

nil.

El primer paso consiste en cargar los módulos que utilizamos:

• aws-sdk carga el módulo AWS SDK para Ruby que utilizamos para invocar la función de Lambda.• json carga el módulo JSON que utilizamos para activar y desactivar la serialización de las cargas de la

solicitud y la respuesta.• os carga el módulo de sistema operativo que utilizamos para garantizar que podemos ejecutar la

aplicación de Ruby en Microsoft Windows. Si utiliza otro sistema operativo, puede quitar estas líneas.

require 'aws-sdk'require 'json'

# To run on Windows:require 'os'if OS.windows? Aws.use_bundled_cert!end

A continuación, cree el cliente de Lambda que utilizamos para invocar la función de Lambda.

client = Aws::Lambda::Client.new(region: 'us-west-2')

A continuación, cree el hash para los argumentos de la solicitud y llame a MyGetItemsFunction.

req_payload = {:SortBy => 'time', :SortOrder => 'descending', :NumberToGet => 10}payload = JSON.generate(req_payload)

63

Page 69: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideConfiguración de una función de

Lambda para recibir notificaciones

resp = client.invoke({ function_name: 'MyGetItemsFunction', invocation_type: 'RequestResponse', log_type: 'None', payload: payload })

Por último, analice la respuesta y, si son correctos, imprima los elementos.

resp_payload = JSON.parse(resp.payload.string) # , symbolize_names: true)

# If the status code is 200, the call succeededif resp_payload["statusCode"] == 200 # If the result is success, we got our items if resp_payload["body"]["result"] == "success" # Print out items resp_payload["body"]["data"].each do |item| puts item end endend

Consulte el ejemplo completo en GitHub.

Configuración de una función de Lambda para recibirnotificacionesEn el siguiente ejemplo se configura la función de Lambda my-notification-function en la regiónus-west-2 para aceptar notificaciones procedentes del recurso con el ARN my-resource-arn.

require 'aws-sdk'

client = Aws::Lambda::Client.new(region: 'us-west-2')

args = {}args[:function_name] = 'my-notification-function'args[:statement_id] = 'lambda_s3_notification'args[:action] = 'lambda:InvokeFunction'args[:principal] = 's3.amazonaws.com'args[:source_arn] = 'my-resource-arn'

client.add_permission{args]

Ejemplos de Amazon Relational Database ServicePuede utilizar los siguientes ejemplos para obtener acceso a Amazon Relational Database Service(Amazon RDS) con AWS SDK for Ruby. Para obtener más información sobre Amazon RDS, consulte laguía del usuario de Amazon Relational Datbase Service.

Note

Algunos de los siguientes ejemplos utilizan métodos que se introdujeron en la versión 2.2.18de la clase Aws::RDS::Resource. Para ejecutar esos ejemplos, debe utilizar esa versión o unaposterior de la gema aws-sdk.

Ejemplos

64

Page 70: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información acerca de todas las instancias

Temas• Obtener información acerca de todas las instancias (p. 65)• Obtener información acerca de todas las instantáneas (p. 65)• Obtener información sobre todos los clústeres y sus instantáneas (p. 65)• Obtener información acerca de todos los grupos de seguridad (p. 66)• Obtener información acerca de todos los grupos de subred (p. 66)• Obtener información acerca de todos los grupos de parámetros (p. 67)• Creación de instantáneas a partir de instancias (p. 67)• Crear una instantánea de un clúster (p. 67)

Obtener información acerca de todas las instanciasEn el siguiente ejemplo se muestran el nombre (ID) y el estado de todas las instancias de Amazon RDS enla región us-west-2.

require 'aws-sdk'

rds = Aws::RDS::Resource.new(region: 'us-west-2') rds.db_instances.each do |i| puts "Name (ID): #{i.id}" puts "Status : #{i.db_instance_status}" putsend

Obtener información acerca de todas las instantáneasEn el siguiente ejemplo se muestran los nombres (ID) y el estado de todas las instantáneas (instancias) deAmazon RDS en la región us-west-2.

require 'aws-sdk'

rds = Aws::RDS::Resource.new(region: 'us-west-2') rds.db_snapshots.each do |s| puts "Name (ID): #{s.snapshot_id}" puts "Status: #{s.status}"end

Obtener información sobre todos los clústeres y susinstantáneasEn el siguiente ejemplo se muestra el nombre (ID) y el estado de todos los clústeres de Amazon RDS y elnombre (ID) y el estado de sus instantáneas en la región us-west-2.

require 'aws-sdk'

rds = Aws::RDS::Resource.new(region: 'us-west-2')

rds.db_clusters.each do |c| puts "Name (ID): #{c.id}" puts "Status: #{c.status}"

65

Page 71: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información acerca detodos los grupos de seguridad

c.snapshots.each do |s| puts " Snapshot: #{s.snapshot_id}" puts " Status: #{s.status}" endend

Obtener información acerca de todos los grupos deseguridadEn el siguiente ejemplo se muestra una lista con los nombres de todos los grupos de seguridad de AmazonRDS en la región us-west-2.

Note

Los grupos de seguridad de Amazon RDS son de aplicación cuando se utiliza la plataformaclásica de Amazon EC2, únicamente. Si utiliza Amazon EC2 VPC, utilice los grupos de seguridadde VPC. Ambos se muestran en el ejemplo.

require 'aws-sdk'

rds = Aws::RDS::Resource.new(region: 'us-west-2')

rds.db_instances.each do |i| # Show any security group IDs and descriptions puts 'Security Groups:'

i.db_security_groups.each do |sg| puts sg.db_security_group_name puts ' ' + sg.db_security_group_description puts end

# Show any VPC security group IDs and their status puts 'VPC Security Groups:'

i.vpc_security_groups.each do |vsg| puts vsg.vpc_security_group_id puts ' ' + vsg.status puts endend

Obtener información acerca de todos los grupos desubredEn el siguiente ejemplo se muestran el nombre y el estado de todos los grupos de subred de Amazon RDSen la región us-west-2.

require 'aws-sdk'

rds = Aws::RDS::Resource.new(region: 'us-west-2') rds.db_subnet_groups.each do |s| puts s.name puts ' ' + s.subnet_group_statusend

66

Page 72: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información acerca detodos los grupos de parámetros

Obtener información acerca de todos los grupos deparámetrosEn el siguiente ejemplo se muestra una lista con los nombres y las descripciones de todos los grupos deparámetros de Amazon RDS de la región us-west-2.

require 'aws-sdk'

rds = Aws::RDS::Resource.new(region: 'us-west-2') rds.db_parameter_groups.each do |p| puts p.db_parameter_group_name puts ' ' + p.descriptionend

Creación de instantáneas a partir de instanciasEn el siguiente ejemplo se crea una instantánea de la instancia de Amazon RDS representada porinstance_name en la región us-west-2.

Note

Si la instancia es miembro de un clúster, no puede crear una instantánea, sino que debe crear unainstantánea del clúster (consulte Creating a Snapshot of a Cluster (p. 67)).

require 'aws-sdk'

rds = Aws::RDS::Resource.new(region: 'us-west-2') instance = rds.db_instance(instance_name) date = Time.newdate_time = date.year.to_s + '-' + date.month.to_s + '-' + date.day.to_s + '-' + date.hour.to_s + '-' + date.min.to_s

id = instance_name + '-' + date_time instance.create_snapshot({db_snapshot_identifier: id})

puts "Created snapshot #{id}"

Crear una instantánea de un clústerEn el siguiente ejemplo se crea una instantánea del clúster de Amazon RDS representado porcluster_name en la región us-west-2.

require 'aws-sdk'

rds = Aws::RDS::Resource.new(region: 'us-west-2') cluster = rds.db_cluster(cluster_name) date = Time.newdate_time = date.year.to_s + '-' + date.month.to_s + '-' + date.day.to_s + '-' + date.hour.to_s + '-' + date.min.to_s

id = cluster_name + '-' + date_time

67

Page 73: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de Amazon S3

cluster.create_snapshot({db_cluster_snapshot_identifier: id})

puts "Created cluster snapshot #{id}"

Ejemplos de Amazon S3Puede utilizar los siguientes ejemplos para tener acceso a Amazon Simple Storage Service (Amazon S3)con AWS SDK for Ruby. Para obtener más información acerca de Amazon S3, consulte la documentaciónde Amazon S3.

Ejemplos

Temas• Obtener información acerca de todos los buckets (p. 68)• Obtener información acerca de todos los buckets de una región (p. 69)• Creación y uso de un bucket de Amazon S3 (p. 69)• Determinar si existe un bucket (p. 73)• Obtener información sobre elementos de buckets (p. 73)• Carga de un elemento en un bucket (p. 74)• Carga de un elemento con metadatos en un bucket (p. 74)• Descargar un objeto de un bucket en un archivo (p. 74)• Cambio de las propiedades de un elemento del bucket (p. 75)• Activación de una notificación cuando se adjunta un elemento a un bucket (p. 75)• Creación de una plantilla de configuración de reglas de ciclo de vida para un bucket (p. 77)• Creación de una política de buckets con Ruby (p. 79)• Configuración de buckets para uso compartido de recursos entre orígenes (CORS) (p. 82)• Administración de permisos de acceso a objetos y buckets de Amazon S3 (p. 85)• Uso de un bucket de Amazon S3 para alojar un sitio web (p. 88)

Obtener información acerca de todos los bucketsEn el siguiente ejemplo se muestran los nombres de hasta 50 de los buckets de Amazon S3. Copie elcódigo y guárdelo como buckets.rb. Tenga en cuenta que aunque el objeto Resource se crea en laregión us-west-2, Amazon S3 devuelve buckets a los que tiene acceso independientemente de la regiónen la que se encuentren.

require 'aws-sdk'

region = 'us-west-2's3 = Aws::S3::Resource.new(region: region)

s3.buckets.limit(50).each do |b| puts "#{b.name}"end

Note

Cuando especifique una región, el método buckets llama al método Client#list_bucketsy devuelve una lista de todos los buckets que son propiedad del remitente autenticado de lasolicitud. Consulte Obtener información acerca de todos los buckets de una región (p. 69)

68

Page 74: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información acerca detodos los buckets de una región

para obtener información sobre cómo filtrar esta lista para obtener solo los buckets de una regiónespecífica.

Obtener información acerca de todos los buckets deuna regiónEn el siguiente ejemplo se muestran los nombres de los primeros 50 buckets de la región us-west-2. Sino se especifica ningún límite, Amazon S3 muestra todos los buckets de us-west-2.

require 'aws-sdk'

region = 'us-west-2's3 = Aws::S3::Resource.new(region: region)

s3.buckets.limit(50).each do |b| if s3.client.get_bucket_location(bucket: b.name).location_constraint == region puts "#{b.name}" endend

Note

Si el bucket no se encuentra en la región donde se ha creado la instancia del objeto Resource,el SDK envía un mensaje de advertencia cuando se llama a get_bucket_location. Puedesuprimir este mensaje redirigiendo STDERR.En Windows, añada 2> nul al comando.En Linux o iOS, añada 2> /dev/null al comando.

Creación y uso de un bucket de Amazon S3En este ejemplo se muestra cómo usar AWS SDK for Ruby para:

1. Muestre una lista de los buckets de Amazon S3.2. Cree un bucket.3. Cargue un objeto (un archivo) en el bucket.4. Copie los archivos en el bucket.5. Elimine los archivos del bucket.

Para obtener el código completo de este ejemplo, consulte Ejemplo completo (p. 71).

Tareas de requisitos previosPara configurar y ejecutar este ejemplo, primero debe:

1. Instale AWS SDK for Ruby. Para obtener más información, consulte AWS SDK para Ruby (p. 4).2. Establezca las credenciales de acceso de AWS que utilizará el AWS SDK for Ruby para verificar el

acceso a los servicios y recursos de AWS. Para obtener más información, consulte Configuración deAWS SDK para Ruby (p. 5).

Asegúrese de que las credenciales de AWS están asignadas a una entidad AWS Identity and AccessManagement (IAM) con acceso a los recursos y acciones de AWS descritos en este ejemplo.

En este ejemplo se presupone que ha configurado las credenciales en el archivo de perfil de credencialesde AWS y ha nombrado el archivo david.

69

Page 75: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación y uso de un bucket de Amazon S3

Configuración del SDKPara este ejemplo, añada declaraciones require para utilizar las clases y los métodos que proporcionaAWS SDK for Ruby para Amazon S3 y trabajar con los datos con formato JSON. Después, cree unobjeto Aws::S3::Client en la región de AWS donde quiere crear el bucket y el perfil de AWS especificado.Este código crea el objeto Aws::S3::Client en la región us-east-1. También se declaran variablesadicionales para los dos buckets usados en este ejemplo.

require 'aws-sdk'require 'json'

profile_name = 'david'region = "us-east-1"bucket = 'doc-sample-bucket'my_bucket = 'david-cloud'

# S3

# Configure SDKs3 = Aws::S3::Client.new(profile: profile_name, region: region)

Obtención de una lista de bucketsLlame al método list_buckets. Esto devuelve una instancia de la clase Aws::S3::Types::ListBucketsOutput,que representa la lista de buckets. A continuación, utilice el atributo buckets de la claseListBucketsOutput para obtener acceder a las propiedades de los buckets como, por ejemplo, namepara el nombre de cada bucket.

resp = s3.list_bucketsresp.buckets.each do |bucket| puts bucket.nameend

Crear un bucketLlame al método create_bucket especificando el nombre del bucket.

Note

Los nombres de bucket deben ser únicos en Amazon S3, no solo en la cuenta de AWS.

s3.create_bucket(bucket: bucket)

Carga de un objeto (un archivo) en un bucketLlame al método put_object, especificando ajustes como, por ejemplo, el nombre del bucket y el nombredel archivo que se va a crear. Para el contenido del archivo, puede especificar una instancia de una claseFile de Ruby o, en este ejemplo, una cadena que representa los datos del archivo.

Para confirmar si el archivo se ha cargado correctamente, llame al método list_objects_v2. Esto devuelveuna instancia de la clase Aws::S3::Types::ListObjectsV2Output, que representa los objetos del bucket. Acontinuación, utilice el método contents de la clase ListObjectsV2Output para obtener acceder a laspropiedades de los objetos como, por ejemplo, key para el nombre de cada objeto.

s3.put_object(bucket: bucket, key: "file1", body: "My first s3 object")

# Check the file existsresp = s3.list_objects_v2(bucket: bucket)

70

Page 76: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación y uso de un bucket de Amazon S3

resp.contents.each do |obj| puts obj.keyend

Copia de archivos entre bucketsLlame al método copy_object, especificando el nombre del bucket de destino que va a recibir el objeto(bucket), los nombres del bucket de origen y del objeto que se van a copiar (copy_source) y el nombredel nuevo objeto que se copia en el bucket de destino (key).

En este ejemplo, el nombre del bucket que contiene los objetos que se van a copiar es #{my_bucket},que es el bucket denominado david-cloud. Después de la operación de copia, el nombre detest_file en el bucket david-cloud cambia a file2 en el bucket doc-sample-bucket, y el nombrede test_file1 en el bucket david-cloud cambia a file3 en el bucket doc-sample-bucket.

s3.copy_object(bucket: bucket, copy_source: "#{my_bucket}/test_file", key: 'file2')s3.copy_object(bucket: bucket, copy_source: "#{my_bucket}/test_file1", key: 'file3')

Eliminación de archivos en un bucketLlame al método delete_objects. Para el argumento delete, utilice una instancia del tipoAws::S3::Types::Delete para representar los objetos que se van a eliminar. En este ejemplo, objectsrepresenta dos archivos que se van a eliminar.

Para confirmar si los archivos se han eliminado correctamente, llame al método list_objects_v2 comoantes. En esta ocasión, cuando utilice el método contents de la clase, los nombres de archivo eliminados(representados aquí por key) no deberían mostrarse.

s3.delete_objects( bucket: 'doc-sample-bucket', delete: { objects: [ { key: 'file2' }, { key: 'file3' } ] })

# Verify objects now have been deletedresp = s3.list_objects_v2(bucket: bucket)resp.contents.each do |obj| puts obj.keyend

Ejemplo completoAquí está el código completo de este ejemplo.

require 'aws-sdk'require 'json'

71

Page 77: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación y uso de un bucket de Amazon S3

profile_name = 'david'region = "us-east-1"bucket = 'doc-sample-bucket'my_bucket = 'david-cloud'

# S3

# Configure SDKs3 = Aws::S3::Client.new(profile: profile_name, region: region)

# Display a List of Amazon S3 Bucketsresp = s3.list_bucketsresp.buckets.each do |bucket| puts bucket.nameend

# Create a S3 bucket from S3::clients3.create_bucket(bucket: bucket)

# Upload a file to s3 bucket, directly putting string datas3.put_object(bucket: bucket, key: "file1", body: "My first s3 object")

# Check the file existsresp = s3.list_objects_v2(bucket: bucket)resp.contents.each do |obj| puts obj.keyend

# Copy files from bucket to buckets3.copy_object(bucket: bucket, copy_source: "#{my_bucket}/test_file", key: 'file2')s3.copy_object(bucket: bucket, copy_source: "#{my_bucket}/test_file1", key: 'file3')

# Delete multiple objects in a single HTTP requests3.delete_objects( bucket: 'doc-sample-bucket', delete: { objects: [ { key: 'file2' }, { key: 'file3' } ] })

# Verify objects now have been deletedresp = s3.list_objects_v2(bucket: bucket)resp.contents.each do |obj| puts obj.keyend

Enfoques alternativosEn el siguiente ejemplo se crea un bucket denominado my-bucket en la región us-west-2. En esteejemplo se utiliza una instancia de la clase Aws::S3::Resource en lugar de la clase Aws::S3::Client.

require 'aws-sdk'

72

Page 78: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideDeterminar si existe un bucket

s3 = Aws::S3::Resource.new(region: 'us-west-2')s3.create_bucket(bucket: 'my-bucket')

Determinar si existe un bucketHay dos casos en los que sería necesario determinar si ya existe o no un bucket. Puede realizar estascomprobaciones en lugar de recibir una excepción si falla la condición:

• Es posible determinar si ya existe un bucket con un nombre específico entre todos los buckets, inclusoentre aquellos a los que no tiene acceso. Esta comprobación ayuda a impedir la creación de un bucketcon el nombre de otro ya existente, lo que produciría una excepción.

• Es posible realizar una operación, como añadir un elemento a un bucket, solo en un bucket al que tieneacceso.

En el siguiente ejemplo se establece bucket_exists en true si ya existe un bucket con el nombre my-bucket. El parámetro region: en Resource no modifica el resultado.

require 'aws-sdk' s3 = Aws::S3::Resource.new(region: 'us-west-2')bucket_exists = s3.bucket('my-bucket').exists?

En el siguiente ejemplo se establece bucket_exists en true si ya existe el bucket con el nombre my-bucket y tiene acceso a él. De nuevo, el parámetro region en Client no modifica el resultado.

require 'aws-sdk'

bucket_exists = falseclient = Aws::S3::Client.new(region: 'us-west-2')

begin resp = client.head_bucket({bucket: bucket_name, use_accelerate_endpoint: false}) bucket_exists = truerescueend

Obtener información sobre elementos de bucketsUna dirección URL prefirmada le permite el acceso al objeto identificado en la misma, si el creador de ladirección URL prefirmada tiene permiso para obtener acceso al objeto. Puede utilizar una URL prefirmadapara permitir que un usuario haga clic en un enlace y vea un elemento sin necesidad de hacerlo público.

En el siguiente ejemplo se muestran los nombres y URL prefirmadas de los primeros 50 elementos delbucket my-bucket en la región us-west-2. Si no se especifica un límite, Amazon S3 muestra hasta1.000 elementos.

require 'aws-sdk'

s3 = Aws::S3::Resource.new(region: 'us-west-2')

bucket = s3.bucket('my-bucket')

# Show only the first 50 itemsbucket.objects.limit(50).each do |item| puts "Name: #{item.key}" puts "URL: #{item.presigned_url(:get)}"end

73

Page 79: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCarga de un elemento en un bucket

Carga de un elemento en un bucketEn el siguiente ejemplo se carga el elemento (archivo) C:file.txt en el bucket my-bucket en la regiónus-west-2. Como C:file.txt es el nombre completo del archivo, el nombre del elemento se estableceen el nombre de archivo.

require 'aws-sdk' s3 = Aws::S3::Resource.new(region: 'us-west-2')

file = 'C:\file.txt'bucket = 'my-bucket' # Get just the file namename = File.basename(file)

# Create the object to uploadobj = s3.bucket(bucket).object(name)

# Upload it obj.upload_file(file)

Carga de un elemento con metadatos en un bucketEn el siguiente ejemplo se carga el elemento (archivo) C:file.txt con el par clave-valor de metadatosanswer y 42 en el bucket my-bucket en la región us-west-2. Como C:file.txt es el nombrecompleto del archivo, el nombre del elemento coincide con el nombre de archivo.

require 'aws-sdk' s3 = Aws::S3::Resource.new(region: 'us-west-2')

file = 'C:\file.txt'bucket = 'my-bucket' # Get just the file namename = File.basename(file)

# Create the object to uploadobj = s3.bucket(bucket).object(name)

# Metadata to addmetadata = {"answer" => "42"}

# Upload it obj.upload_file(file, metadata: metadata)

Descargar un objeto de un bucket en un archivoEn el siguiente ejemplo se obtiene el contenido del elemento my-item del bucket my-bucket en la regiónus-west-2 y se guarda en el archivo my-item.txt del ./my-code directorio.

require 'aws-sdk'

s3 = Aws::S3::Resource.new(region: 'us-west-2')

# Create the object to retrieveobj = s3.bucket('my-bucket').object('my-item')

74

Page 80: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCambio de las propiedades de un elemento del bucket

# Get the item's content and save it to a fileobj.get(response_target: './my-code/my-item.txt')

Cambio de las propiedades de un elemento del bucketEn el siguiente ejemplo se añade acceso de solo lectura público, se establece el cifrado del servidor enAES-256 y se establece la clase de almacenamiento de redundancia reducida para el elemento my-itemdel bucket my-bucket en la región us-west-2.

require 'aws-sdk'

args_list = {}args_list[:bucket] = 'my-bucket'args_list[:key] = 'my-item'

# Where we are getting the source to copy fromargs_list[:copy_source] = 'my-bucket/my-item'

# The acl can be any of:# private, public-read, public-read-write, authenticated-read, aws-exec-read, bucket-owner-read, bucket-owner-full-controlargs_list[:acl] = 'public-read'

# The encryption can be any of:# AES256, aws:kmsargs_list[:server_side_encryption] = 'AES256'

# The storage_class can be any of:# STANDARD, REDUCED_REDUNDANCY, STANDARD_IAargs_list[:storage_class] = 'REDUCED_REDUNDANCY'

client = Aws::S3::Client.new(region: 'us-west-2')

client.copy_object(args_list)

Activación de una notificación cuando se adjunta unelemento a un bucketPuede activar el envío de una notificación cuando se produzca un cambio en los objetos de un bucket.Entre estos cambios se incluyen los siguientes:

• Cuando se adjunta un objeto al bucket• Cuando se quita un objeto del bucket• Cuando se pierde un objeto con almacenamiento de redundancia reducida

Puede configurar el servicio para enviar una notificación a:

• Un tema de Amazon SNS• Una cola de Amazon SQS• Una función Lambda

Para crear una notificación del bucket

1. Conceda a Amazon S3 permiso para publicar un elemento en una cola o tema o para invocar unafunción de Lambda (p. 76).

75

Page 81: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideActivación de una notificación cuandose adjunta un elemento a un bucket

2. Establezca la configuración de notificaciones del bucket para apuntar a la cola, el tema o lafunción (p. 76).

Después de realizar estos pasos, la aplicación puede responder a la información. Por ejemplo, el temade Lambda Modelo de programación describe cómo utilizar los distintos lenguajes de programación queadmite Lambda.

Habilitar Amazon S3 para enviar notificacionesObtenga información sobre cómo configurar un tema de Amazon Simple Notification Service o una cola deAmazon Simple Queue Service o bien crear una función de Lambda para que Amazon S3 pueda enviarlesuna notificación.

• Habilitar un recurso para publicarlo en un tema (p. 93)• Habilitar un recurso para publicarlo en una cola de Amazon SQS (p. 102)• Configuración de una función de Lambda para recibir notificaciones (p. 64)

Creación de una notificación del bucket de Amazon S3En el siguiente ejemplo se habilita el bucket de Amazon S3 my-bucket para enviar una notificación a lossiguientes destinos cuando se añade un elemento al bucket:

• El tema de Amazon SNS con el ARN my-topic-arn• La cola de Amazon SQS con el ARN my-queue-arn• La función de Lambda con el ARN my-function-arn

require 'aws-sdk'

req = {}req[:bucket] = bucket_name

events = ['s3:ObjectCreated:*']

notification_configuration = {}

# Add functionlc = {}

lc[:lambda_function_arn] = 'my-function-arn'lc[:events] = eventslambda_configurations = []lambda_configurations << lc

notification_configuration[:lambda_function_configurations] = lambda_configurations

# Add queueqc = {}

qc[:queue_arn] = 'my-topic-arn'qc[:events] = eventsqueue_configurations = []queue_configurations << qc

notification_configuration[:queue_configurations] = queue_configurations

# Add topictc = {}

76

Page 82: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una plantilla de configuraciónde reglas de ciclo de vida para un bucket

tc[:topic_arn] = 'my-topic-arn'tc[:events] = eventstopic_configurations = []topic_configurations << tc

notification_configuration[:topic_configurations] = topic_configurations

req[:notification_configuration] = notification_configuration

req[:use_accelerate_endpoint] = false

s3 = Aws::S3::Client.new(region: 'us-west-2')

s3.put_bucket_notification_configuration(req)

Creación de una plantilla de configuración de reglasde ciclo de vida para un bucketSi tiene (o ha previsto crear) un número no trivial de objetos y desea especificar cuándo trasladarlos parasu almacenamiento a largo plazo o eliminarlos, puede ahorrar mucho tiempo a través de la creación de unaplantilla de reglas del ciclo de vida y la aplicación de dicha plantilla a todos los buckets.

El proceso incluye los siguientes pasos:

1. Modificar manualmente la configuración del ciclo de vida de un bucket existente.2. Guardar las reglas.3. Aplicar las reglas al resto de buckets.

Comience con la siguiente regla:

77

Page 83: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una plantilla de configuraciónde reglas de ciclo de vida para un bucket

Ejecute el siguiente código para producir una representación de JSON de dicha regla. Guarde el resultadocomo default.json.

require 'aws-sdk'

s3 = Aws::S3::Client.new(region: 'us-west-2')resp = s3.get_bucket_lifecycle_configuration(bucket: 'default')

resp.rules.each do |rule| rule.to_hash.to_jsonend

El resultado debe tener el siguiente aspecto:

[{"expiration":{"date":null,"days":425},"id":"default","prefix":"","status":"Enabled","transitions":[{"date":null,"days":30,"storage_class":"STANDARD_IA"},{"date":null,"days":60,"storage_class":"GLACIER"}],"noncurrent_version_transitions":[],"noncurrent_version_expiration":null}]

Ahora que tiene el JSON para una regla del ciclo de vida, puede aplicarlo a cualquier otro bucket medianteel siguiente ejemplo, donde se toma la regla de default.json y se aplica al bucket other_bucket:

require 'aws-sdk'require 'json'

class Aws::S3::Types::LifecycleExpiration def to_map map = Hash.new self.members.each { |m| map[m] = self[m] } map end

def to_json(*a) to_map.to_json(*a) endend

class Aws::S3::Types::Transition def to_map map = Hash.new self.members.each { |m| map[m] = self[m] } map end

def to_json(*a) to_map.to_json(*a) endend

class Aws::S3::Types::LifecycleRule def to_map map = Hash.new self.members.each { |m| map[m] = self[m] } map end

def to_json(*a) to_map.to_json(*a) endend

78

Page 84: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una política de buckets con Ruby

# Pull in contents as a stringvalue = File.open('default.json', "rb").readjson_data = JSON.parse(value, opts={symbolize_names: true})

s3 = Aws::S3::Client.new(region: 'us-west-2')s3.put_bucket_lifecycle_configuration(:bucket => 'other_bucket', :lifecycle_configuration => {:rules => json_data})

<admonition><title>Práctica recomendada</title>

Le recomendamos que habilite la regla del ciclo de vida AbortIncompleteMultipartUpload en los buckets deAmazon S3.

Esta regla le indica a Amazon S3 que anule las cargas multiparte que no se completan en un númeroespecificado de días después de iniciarse. Cuando se supera el plazo establecido, Amazon S3 anula lacarga y, a continuación, elimina la carga de datos incompleta.

Para obtener más información, consulte Configuración de ciclo de vida para un bucket con control deversiones en la Amazon S3 User Guide.</admonition>

Creación de una política de buckets con RubyEn este ejemplo se muestra cómo usar AWS SDK for Ruby para:

1. Crear un bucket en Amazon Simple Storage Service (Amazon S3).2. Definir una política de bucket.3. Añadir la política al bucket.4. Cambiar la política.5. Eliminar la política del bucket.6. Eliminar el bucket.

Para obtener el código completo de este ejemplo, consulte Ejemplo completo (p. 81).

Tareas de requisitos previosPara configurar y ejecutar este ejemplo, primero debe:

1. Instale AWS SDK for Ruby. Para obtener más información, consulte AWS SDK para Ruby (p. 4).2. Establezca las credenciales de acceso de AWS que utilizará el AWS SDK for Ruby para verificar el

acceso a los servicios y recursos de AWS. Para obtener más información, consulte Configuring theAWS SDK for Ruby (p. 5).

Asegúrese de que las credenciales de AWS están asignadas a una entidad AWS Identity and AccessManagement (IAM) con acceso a los recursos y acciones de AWS descritos en este ejemplo.

En este ejemplo se supone que ha establecido las credenciales en el archivo del perfil de credenciales deAWS o en las variables de entorno AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEY del sistema local.

Configuración del SDKPara configurar el SDK para este ejemplo, añada una declaración require para usar las clases y losmétodos que proporciona el AWS SDK for Ruby para Amazon S3. Después, cree un objeto Aws::S3::Client

79

Page 85: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una política de buckets con Ruby

en la región de AWS donde quiere crear el bucket. Este código crea el objeto Aws::S3::Client en laregión us-west-2.

require 'aws-sdk'

s3 = Aws::S3::Client.new(region: "us-west-2")

Crear un bucketLlame al método create_bucket especificando el nombre del bucket. Este código utiliza una variablellamada bucket para representar el nombre del bucket. Cambie example-bucket-name por el nombredel bucket.

Note

Los nombres de bucket deben ser únicos en Amazon S3, no solo en la cuenta de AWS.

Si ya tiene un bucket que desee utilizar, no tiene que llamar a create_bucket.

bucket = "example-bucket-name"

s3.create_bucket(bucket: bucket)

Definir una política de bucketDeclare un hash de Ruby que represente la política. Después, llame al método to_json en el hash paraconvertirlo en un objeto JSON. Este código utiliza una variable llamada policy que contiene la definiciónde la política. Esta política permite que el usuario especificado tenga control total sobre example-bucket-name (representado por #{bucket}). Cambie arn:aws:iam::111122223333:user/Alicepor el Amazon Resource Name (ARN) del usuario de AWS Identity and Access Management (IAM) quedesea utilizar.

policy = { "Version" => "2012-10-17", "Statement" => [ { "Effect" => "Allow", "Principal" => { "AWS" => [ "arn:aws:iam::111122223333:user/Alice" ] }, "Action" => "s3:*", "Resource" => [ "arn:aws:s3:::#{bucket}" ] } ]}.to_json

Para ver ejemplos de los tipos de políticas que se pueden definir, consulte Ejemplos de política de bucketen la Amazon S3 Developer Guide.

Añadir la política al bucketLlame al método put_bucket_policy especificando el nombre del bucket y la definición de la política.

80

Page 86: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una política de buckets con Ruby

s3.put_bucket_policy( bucket: bucket, policy: policy)

Cambiar la políticaPuede llamar al método put_bucket_policy de nuevo con una política de sustitución completa. Sinembargo, también puede realizar actualizaciones incrementales en una política existente, para reducirla cantidad de código que es preciso escribir. Para ello, recupere la política actual llamando al métodoget_bucket_policy. A continuación, analice el objeto JSON que se devuelve en un hash de Ruby. Acontinuación, efectúe los cambios incrementales en la política. Por ejemplo, este código cambia el ARNde la entidad IAM. Después de efectuar los cambios, llame al método put_bucket_policy de nuevo.Asegúrese de llamar al método to_json en el hash para convertirlo de nuevo en un objeto JSON antes deaplicar la política modificada al bucket.

policy_string = s3.get_bucket_policy(bucket: bucket).policy.readpolicy_json = JSON.parse(policy_string)

policy_json["Statement"][0]["Principal"]["AWS"] = "arn:aws:iam::111122223333:root"

s3.put_bucket_policy( bucket: bucket, policy: policy_json.to_json)

EliminaciónPara eliminar la política del bucket, llame al método delete_bucket_policy especificando el nombre delbucket.

Para eliminar el bucket, llame al método delete_bucket especificando el nombre del bucket.

s3.delete_bucket_policy(bucket: bucket)s3.delete_bucket(bucket: bucket)

Ejemplo completoAquí está el código completo de este ejemplo.

require 'aws-sdk'

s3 = Aws::S3::Client.new(region: "us-west-2")

bucket = "example-bucket-name"

s3.create_bucket(bucket: bucket)

policy = { "Version" => "2012-10-17", "Statement" => [ { "Effect" => "Allow", "Principal" => { "AWS" => [ "arn:aws:iam::111122223333:user/Alice" ]

81

Page 87: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideConfiguración de buckets para uso compartido

de recursos entre orígenes (CORS)

}, "Action" => "s3:*", "Resource" => [ "arn:aws:s3:::#{bucket}" ] } ]}.to_json

s3.put_bucket_policy( bucket: bucket, policy: policy)

policy_string = s3.get_bucket_policy(bucket: bucket).policy.readpolicy_json = JSON.parse(policy_string)

policy_json["Statement"][0]["Principal"]["AWS"] = "arn:aws:iam::111122223333:root"

s3.put_bucket_policy( bucket: bucket, policy: policy_json.to_json)

s3.delete_bucket_policy(bucket: bucket)s3.delete_bucket(bucket: bucket)

Configuración de buckets para uso compartido derecursos entre orígenes (CORS)En este ejemplo se muestra cómo usar AWS SDK for Ruby para:

1. Configurar CORS para un bucket de Amazon S3.2. Obtener la configuración CORS para un bucket.

Para obtener más información sobre la compatibilidad con CORS en Amazon S3, consulte Cross-OriginResource Sharing (CORS, Uso compartido de recursos entre orígenes) en la Amazon S3 Developer Guide.

Para obtener el código completo de este ejemplo, consulte Ejemplo completo (p. 84).

Tareas de requisitos previosPara configurar y ejecutar este ejemplo, primero debe:

1. Instale AWS SDK for Ruby. Para obtener más información, consulte AWS SDK para Ruby (p. 4).2. Establezca las credenciales de acceso de AWS que utilizará el AWS SDK for Ruby para verificar el

acceso a los servicios y recursos de AWS. Para obtener más información, consulte Configuring theAWS SDK for Ruby (p. 5).

3. Cree un bucket Amazon S3 o identifique uno existente en la cuenta de AWS.

Asegúrese de que las credenciales de AWS están asignadas a una entidad AWS Identity and AccessManagement (IAM) con acceso a los recursos y acciones de AWS descritos en este ejemplo.

En este ejemplo se supone que:

• Ha establecido las credenciales en el archivo del perfil de credenciales de AWS y el perfil se llamadavid.

82

Page 88: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideConfiguración de buckets para uso compartido

de recursos entre orígenes (CORS)

• El bucket se llama doc-sample-bucket.

Configuración del SDKPara este ejemplo, añada una declaración require para utilizar las clases y los métodos queproporciona el AWS SDK for Ruby para Amazon S3. Después, cree un objeto Aws::S3::Client en laregión de AWS donde quiere crear el bucket y el perfil de AWS especificado. Este código crea el objetoAws::S3::Client en la región us-east-1. También se declara una variable adicional para el bucketusado en este ejemplo

require 'aws-sdk'

profile_name = 'david'region = 'us-east-1'bucket = 'doc-sample-bucket'

# S3 - Configuring an S3 Bucket

# Create a S3 clients3 = Aws::S3::Client.new(profile: profile_name, region:region)

Configurar CORS para un bucketLlame al método put_bucket_cors proporcionando el nombre del bucket y la configuración de CORS.

s3.put_bucket_cors( bucket: bucket, cors_configuration: cors_configuration)

Para los valores de configuración de CORS, declare un hash Aws::S3::Types::CORSConfiguration.Especifique cosas como, por ejemplo, los métodos HTTP que los orígenes especificados pueden ejecutar(allowed_methods), los orígenes desde los que desea que los clientes tengan acceso al bucket(allowed_origins) y los encabezados de la respuesta a la que desea que los clientes puedan teneracceso desde las aplicaciones (por ejemplo, un objeto XMLHttpRequest de JavaScript que se muestraaquí en expose_headers).

cors_configuration = { cors_rules: [ { allowed_methods: allowed_methods, allowed_origins: ["*"], expose_headers: ["ExposeHeader"], }, ]}

Puede insertar los métodos HTTP que los orígenes especificados pueden ejecutar, como se muestra aquí,o puede obtenerlos del usuario en la línea de comandos.

allowed_methods = []ARGV.each do |arg| case arg.upcase when "POST" allowed_methods << "POST" when "GET" allowed_methods << "GET"

83

Page 89: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideConfiguración de buckets para uso compartido

de recursos entre orígenes (CORS)

when "PUT" allowed_methods << "PUT" when "PATCH" allowed_methods << "PATCH" when "DELETE" allowed_methods << "DELETE" when "HEAD" allowed_methods << "HEAD" else puts "#{arg} is not a valid HTTP method" endend

Por ejemplo, suponiendo que el archivo de código se llama doc_sample_code_s3_bucket_cors.rb yque desea permitir que los orígenes especificados ejecuten solo métodos GET y POST, aquí se muestracómo el usuario podría ejecutar el código desde la línea de comandos.

ruby doc_sample_code_s3_bucket_cors.rb get post

Obtener la configuración CORS para un bucketLlame al método get_bucket_cors proporcionando el nombre del bucket. El método get_bucket_corsdevuelve un objeto Aws::S3::Types::GetBucketCorsOutput. Este atributo cors_rules del objeto devuelveuna matriz de objetos Aws::S3::Types::CORSRule que representa la configuración CORS del bucket.

resp = s3.get_bucket_cors(bucket: bucket)puts resp.cors_rules

Ejemplo completoAquí está el código completo de este ejemplo.

require 'aws-sdk'

profile_name = 'david'region = 'us-east-1'bucket = 'doc-sample-bucket'

# S3 - Configuring an S3 Bucket

# Create a S3 clients3 = Aws::S3::Client.new(profile: profile_name, region:region)

# Setting a Bucket CORS Configuration

# Create array of allowed methods parameter based on command line parametersallowed_methods = []ARGV.each do |arg| case arg.upcase when "POST" allowed_methods << "POST" when "GET" allowed_methods << "GET" when "PUT" allowed_methods << "PUT" when "PATCH" allowed_methods << "PATCH" when "DELETE" allowed_methods << "DELETE"

84

Page 90: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministración de permisos de acceso

a objetos y buckets de Amazon S3

when "HEAD" allowed_methods << "HEAD" else puts "#{arg} is not a valid HTTP method" endend

# Create CORS configuration hashcors_configuration = { cors_rules: [ { allowed_methods: allowed_methods, allowed_origins: ["*"], expose_headers: ["ExposeHeader"], }, ]}

# Set the new CORS configuration on the selected buckets3.put_bucket_cors( bucket: bucket, cors_configuration: cors_configuration)

# Retrieving a Bucket CORS Configurationresp = s3.get_bucket_cors(bucket: bucket)puts resp.cors_rules

# To run the example, type the following at the command line including one or more HTTP methods as shown# ruby doc_sample_code_s3_bucket_cors.rb get post

Administración de permisos de acceso a objetos ybuckets de Amazon S3En este ejemplo se muestra cómo usar AWS SDK for Ruby para:

1. Establezca una concesión predefinida (también conocida como ACL predefinida) para un bucket enAmazon S3.

2. Añada un objeto al bucket.3. Establezca una ACL predefinida para un objeto en el bucket.4. Obtenga la ACL actual del bucket.

Para obtener el código completo de este ejemplo, consulte Ejemplo completo (p. 87).

Tareas de requisitos previosPara configurar y ejecutar este ejemplo, primero debe:

1. Instale AWS SDK for Ruby. Para obtener más información, consulte AWS SDK para Ruby (p. 4).2. Establezca las credenciales de acceso de AWS que utilizará el AWS SDK for Ruby para verificar el

acceso a los servicios y recursos de AWS. Para obtener más información, consulte Configuración deAWS SDK para Ruby (p. 5).

Asegúrese de que las credenciales de AWS están asignadas a una entidad AWS Identity and AccessManagement (IAM) con acceso a los recursos y acciones de AWS descritos en este ejemplo.

85

Page 91: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministración de permisos de acceso

a objetos y buckets de Amazon S3

En este ejemplo se supone que ha establecido las credenciales en el archivo del perfil de credenciales deAWS o en las variables de entorno AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEY del sistema local.

Configuración del SDKPara este ejemplo, añada una declaración require para utilizar las clases y los métodos que proporcionael AWS SDK for Ruby para Amazon S3. Después, cree un objeto Aws::S3::Client en la región de AWSdonde quiere crear el bucket. Este código crea el objeto Aws::S3::Client en la región us-west-2.Este código también declara una variable que representa el bucket.

require 'aws-sdk'

# Create a S3 clientclient = Aws::S3::Client.new(region: 'us-west-2')

Establecimiento de una ACL predefinida para un bucketLlame al método put_bucket_acl, especificando los nombres de la ACL predefinida y del bucket. Estecódigo establece la ACL predefinida public-read en el bucket, lo que permite al propietario del buckettener un control total sobre este y a los demás usuarios, un acceso de solo lectura.

client.put_bucket_acl({ acl: "public-read", bucket: bucket,})

Para obtener más información acerca de las ACL predefinidas, consulte ACL predefinidas en Informacióngeneral de las Access Control Lists (ACL, Listas de control de acceso) en la Amazon S3 Developer Guide.

Para confirmar esta configuración, llame al método Net::HTTP.get de Ruby para intentar obtener elcontenido del bucket.

bucket_path = "http://#{bucket}.s3-us-west-2.amazonaws.com/"resp = Net::HTTP.get(URI(bucket_path))puts "Content of unsigned request to #{bucket_path}:\n\n#{resp}\n\n"

Carga de un objeto en un bucketLlame al método put_object, especificando los nombres del bucket y del objeto y el contenido del objeto.Este código declara una variable que representa el objeto.

object_key = "my-key"# Put an object in the public bucketclient.put_object({ bucket: bucket, key: object_key, body: 'Hello World',})

Establecimiento de una ACL predefinida para un objetoDe forma predeterminada, no se puede obtener el contenido del objeto en el bucket. Para confirmar estecomportamiento, llame al método Net::HTTP.get de Ruby para intentar obtener el contenido del objeto.

object_path = "http://#{bucket}.s3-us-west-2.amazonaws.com/#{object_key}"

86

Page 92: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideAdministración de permisos de acceso

a objetos y buckets de Amazon S3

resp = Net::HTTP.get(URI(object_path))puts "Content of unsigned request to #{object_path}:\n\n#{resp}\n\n"

Para cambiar este comportamiento, llame al método put_object_acl, especificando los nombres de la ACLpredefinida, del bucket y del objeto. Este código establece la ACL predefinida public-read en el objeto,lo que permite al propietario del objeto tener un control total sobre este y a los demás usuarios, un accesode solo lectura. Después de realizar la llamada, intente de nuevo obtener el contenido del objeto.

client.put_object_acl({ acl: "public-read", bucket: bucket, key: object_key,})object_path = "http://#{bucket}.s3-us-west-2.amazonaws.com/#{object_key}"puts "Now I can access object (#{object_key}) :\n#{Net::HTTP.get(URI(object_path))}\n\n"

Obtención de la ACL actual de un bucketLlame al método get_bucket_acl, especificando el nombre del bucket. El método get_bucket_acldevuelve una instancia de la clase Aws::S3::Types::GetBucketAclOutput. Utilice el atributo grants de laclase GetBucketAclOutput para mostrar la ACL actual del bucket.

resp = client.get_bucket_acl(bucket: bucket)puts resp.grants

Ejemplo completoAquí está el código completo de este ejemplo.

require 'aws-sdk'

# Create a S3 clientclient = Aws::S3::Client.new(region: 'us-west-2')

bucket = 'my-bucket'# Sets a bucket to public-readclient.put_bucket_acl({ acl: "public-read", bucket: bucket,})

object_key = "my-key"# Put an object in the public bucketclient.put_object({ bucket: bucket, key: object_key, body: 'Hello World',})

# Accessing an object in the bucket with unauthorize requestbucket_path = "http://#{bucket}.s3-us-west-2.amazonaws.com/"resp = Net::HTTP.get(URI(bucket_path))puts "Content of unsigned request to #{bucket_path}:\n\n#{resp}\n\n"

# However, accessing the object is denied since object Acl is not public-readobject_path = "http://#{bucket}.s3-us-west-2.amazonaws.com/#{object_key}"resp = Net::HTTP.get(URI(object_path))puts "Content of unsigned request to #{object_path}:\n\n#{resp}\n\n"

87

Page 93: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideUso de un bucket de Amazon S3 para alojar un sitio web

# Setting the object to public-readclient.put_object_acl({ acl: "public-read", bucket: bucket, key: object_key,})object_path = "http://#{bucket}.s3-us-west-2.amazonaws.com/#{object_key}"puts "Now I can access object (#{object_key}) :\n#{Net::HTTP.get(URI(object_path))}\n\n"

# Setting bucket to private againclient.put_bucket_acl({ bucket: bucket, acl: 'private',})

# Get current bucket Aclresp = client.get_bucket_acl(bucket: bucket)puts resp.grants

resp = Net::HTTP.get(URI(bucket_path))puts "Content of unsigned request to #{bucket_path}:\n\n#{resp}\n\n"

Uso de un bucket de Amazon S3 para alojar un sitiowebEn este ejemplo se muestra cómo usar AWS SDK for Ruby para:

1. Cree un bucket de Amazon S3.2. Obtenga la configuración de sitio web del bucket.3. Añada objetos al bucket.4. Establezca la configuración de sitio web del bucket.5. Acceda a los documentos del sitio web del bucket.6. Elimine el sitio web del bucket.7. Eliminar el bucket.

Para obtener más información acerca del alojamiento de sitios web de buckets, consulte Configuración deun bucket para alojamiento de sitios web en la Amazon S3 Developer Guide.

Para obtener el código completo de este ejemplo, consulte Ejemplo completo (p. 90).

Tareas de requisitos previosPara configurar y ejecutar este ejemplo, primero debe:

1. Instale AWS SDK for Ruby. Para obtener más información, consulte AWS SDK para Ruby (p. 4).2. Establezca las credenciales de acceso de AWS que utilizará el AWS SDK for Ruby para verificar el

acceso a los servicios y recursos de AWS. Para obtener más información, consulte Configuración deAWS SDK para Ruby (p. 5).

Asegúrese de que las credenciales de AWS están asignadas a una entidad AWS Identity and AccessManagement (IAM) con acceso a los recursos y acciones de AWS descritos en este ejemplo.

En este ejemplo se supone que ha establecido las credenciales en el archivo del perfil de credenciales deAWS o en las variables de entorno AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEY del sistema local.

88

Page 94: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideUso de un bucket de Amazon S3 para alojar un sitio web

Configuración del SDKPara este ejemplo, añada una declaración require para utilizar las clases y los métodos queproporciona el AWS SDK for Ruby para Amazon S3. Después, cree un objeto Aws::S3::Client en laregión de AWS donde quiere crear el bucket y el perfil de AWS especificado. Este código crea el objetoAws::S3::Client en la región us-east-2.

También se declara una variable adicional para el bucket usado en este ejemplo. Para ayudar a garantizarque el nombre del bucket sea único para todas las cuentas de AWS, se añade una declaración adicionalrequire, y se llama al método uuid del módulo SecureRandom para generar un identificador único. Esteidentificador se inserta en el nombre del bucket que se va a crear más adelante en este ejemplo.

require 'aws-sdk'

# Using Random UUIDs to Avoid Collisions when Testingrequire 'securerandom'bucket = "example-test-bucket-#{SecureRandom.uuid}"

# Setups3 = Aws::S3::Client.new(region: "us-west-2")

Crear un bucketLlame al método create_bucket, especificando el nombre del bucket que se va a crear.

s3.create_bucket(bucket: bucket)

Obtención de la configuración de sitio web de un bucketLlame al método get_bucket_website, especificando el nombre del bucket. De manera predeterminada,el bucket no está configurado como sitio web. Para confirmar este comportamiento, llame al métodoget_bucket_website. Esto devuelve un error, ya que no hay ninguna configuración de sitio web para elbucket.

begin s3.get_bucket_website(bucket: bucket)rescue Aws::S3::Errors::NoSuchWebsiteConfiguration puts "No bucket website configuration present."end

Añadir un objeto a un bucketLlame al método put_object, especificando el nombre del bucket y del objeto, el contenido del objeto y lospermisos de acceso a los objetos establecidos. En este ejemplo se añaden dos páginas web al bucket.

s3.put_object( bucket: bucket, key: "index.html", body: "Hello, Amazon S3!", acl: "public-read")s3.put_object( bucket: bucket, key: "error.html", body: "Page not found!", acl: "public-read"

89

Page 95: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideUso de un bucket de Amazon S3 para alojar un sitio web

)

Establecimiento de la configuración de sitio web de un bucketLlame al método put_bucket_website, especificando el nombre del bucket y la configuración de sitio web.Para la configuración de sitio web, utilice un hash Aws::S3::Types::WebsiteConfiguration, especificando elíndice y las páginas de error del sitio web.

s3.put_bucket_website( bucket: bucket, website_configuration: { index_document: { suffix: "index.html" }, error_document: { key: "error.html" } })

Acceso a los documentos del sitio web de un bucketLlame al método Net::HTTP.get de Ruby, especificando la dirección del documento en el sitio web delbucket.

index_path = "http://#{bucket}.s3-website-us-west-2.amazonaws.com/"error_path = "http://#{bucket}.s3-website-us-west-2.amazonaws.com/nonexistant.html"

puts "Index Page Contents:\n#{Net::HTTP.get(URI(index_path))}\n\n"puts "Error Page Contents:\n#{Net::HTTP.get(URI(error_path))}\n\n"

Eliminación del sitio web de un bucketLlame al método delete_bucket_website, especificando el nombre del bucket.

s3.delete_bucket_website(bucket: bucket)

Eliminar un bucketLlame al método bucket de un objeto Aws::S3::Resource, especificando el nombre del bucket. Estodevuelve un objeto Aws::S3::Bucket. A continuación, llame al método de eliminación del objetoAws::S3::Bucket.

b = Aws::S3::Resource.new(region: "us-west-2").bucket(bucket)b.delete! # Recursively deletes objects as well.

Ejemplo completoAquí está el código completo de este ejemplo.

require 'aws-sdk'

# Using Random UUIDs to Avoid Collisions when Testingrequire 'securerandom'bucket = "example-test-bucket-#{SecureRandom.uuid}"

90

Page 96: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de Amazon SNS

# Setups3 = Aws::S3::Client.new(region: "us-west-2")s3.create_bucket(bucket: bucket)

# When Bucket Has No Website Configurationbegin s3.get_bucket_website(bucket: bucket)rescue Aws::S3::Errors::NoSuchWebsiteConfiguration puts "No bucket website configuration present."end

# Adding Simple Pages & Website Configurations3.put_object( bucket: bucket, key: "index.html", body: "Hello, Amazon S3!", acl: "public-read")s3.put_object( bucket: bucket, key: "error.html", body: "Page not found!", acl: "public-read")s3.put_bucket_website( bucket: bucket, website_configuration: { index_document: { suffix: "index.html" }, error_document: { key: "error.html" } })

# Accessing as a Websiteindex_path = "http://#{bucket}.s3-website-us-west-2.amazonaws.com/"error_path = "http://#{bucket}.s3-website-us-west-2.amazonaws.com/nonexistant.html"

puts "Index Page Contents:\n#{Net::HTTP.get(URI(index_path))}\n\n"puts "Error Page Contents:\n#{Net::HTTP.get(URI(error_path))}\n\n"

# Removing Website Configurations3.delete_bucket_website(bucket: bucket)

# Cleanupb = Aws::S3::Resource.new(region: "us-west-2").bucket(bucket)b.delete! # Recursively deletes objects as well.

Ejemplos de Amazon SNSPuede utilizar los siguientes ejemplos para obtener acceso a Amazon Simple Notification Service (AmazonSNS) con AWS SDK for Ruby. Para obtener más información acerca de Amazon SNS, consulte ladocumentación de Amazon SNS.

Ejemplos

Temas• Obtener información sobre todos los temas (p. 92)• Creación de un tema (p. 92)

91

Page 97: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideObtener información sobre todos los temas

• Obtener información acerca de todas las suscripciones de un tema (p. 92)• Creación de una suscripción en un tema (p. 92)• Envío de un mensaje a todos los suscriptores del tema (p. 93)• Habilitación de un recurso para publicarlo en un tema (p. 93)

Obtener información sobre todos los temasEn el siguiente ejemplo se muestran los ARN de los temas de SNS de la región us-west-2.

require 'aws-sdk'

sns = Aws::SNS::Resource.new(region: 'us-west-2')

sns.topics.each do |topic| puts topic.arnend

Creación de un temaEn el siguiente ejemplo se crea el tema MyGroovyTopic en la región us-west-2 y se muestra el ARNdel tema resultante.

require 'aws-sdk'

sns = Aws::SNS::Resource.new(region: 'us-west-2')

topic = sns.create_topic(name: 'MyGroovyTopic')puts topic.arn

Obtener información acerca de todas las suscripcionesde un temaEn el siguiente ejemplo se muestran las direcciones de correo electrónico de las suscripciones de SNSpara el tema con el ARN arn:aws:sns:us-west-2:123456789:MyGroovyTopic en la región us-west-2.

require 'aws-sdk'

sns = Aws::SNS::Resource.new(region: 'us-west-2')

topic = sns.topic('arn:aws:sns:us-west-2:123456789:MyGroovyTopic')

topic.subscriptions.each do |s| puts s.attributes['Endpoint']end

Creación de una suscripción en un temaEn el siguiente ejemplo se crea una suscripción para el tema con el ARN arn:aws:sns:us-west-2:123456789:MyGroovyTopic para un usuario que tiene la dirección de correo electró[email protected] en la región us-west-2 y muestra el ARN resultante. Al comienzo, elvalor ARN está pendiente de confirmación. Cuando el usuario confirma la dirección de correo electrónico,este valor se convierte en un ARN real.

92

Page 98: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEnvío de un mensaje a todos los suscriptores del tema

require 'aws-sdk'

sns = Aws::SNS::Resource.new(region: 'us-west-2')

topic = sns.topic('arn:aws:sns:us-west-2:123456789:MyGroovyTopic')

sub = topic.subscribe({ protocol: 'email', endpoint: '[email protected]'})

puts sub.arn

Envío de un mensaje a todos los suscriptores del temaEn el siguiente ejemplo se envía el mensaje "Hello!" a todos los suscriptores del tema con el ARNarn:aws:sns:us-west-2:123456789:MyGroovyTopic.

require 'aws-sdk'

sns = Aws::SNS::Resource.new(region: 'us-west-2')

topic = sns.topic('arn:aws:sns:us-west-2:123456789:MyGroovyTopic')

topic.publish({ message: 'Hello!'})

Habilitación de un recurso para publicarlo en un temaEn el siguiente ejemplo se habilita el recurso con el ARN my-resource-arn para publicar en el tema conel ARN my-topic-arn en la región us-west-2.

require 'aws-sdk'

sns = Aws::SNS::Resource.new(region: 'us-west-2')

policy = '{ "Version":"2008-10-17", "Id":"__default_policy_ID", "Statement":[{ "Sid":"__default_statement_ID", "Effect":"Allow", "Principal":{ "AWS":"*" }, "Action":["SNS:Publish"], "Resource":"' + my-topic-arn + '", "Condition":{ "ArnEquals":{ "AWS:SourceArn":"' + my-resource-arn + '"} } }]}'

topic.set_attributes({ attribute_name: "Policy", attribute_value: policy})

93

Page 99: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEjemplos de Amazon SQS

Ejemplos de Amazon SQSPuede utilizar los siguientes ejemplos para obtener acceso a Amazon Simple Queue Service (AmazonSQS) con AWS SDK for Ruby. Para obtener más información acerca de Amazon SQS, consulte ladocumentación de Amazon SQS.

Ejemplos

Temas• Obtener información acerca de todas las colas en Amazon SQS (p. 94)• Creación de una cola en Amazon SQS (p. 95)• Uso de colas en Amazon SQS (p. 95)• Envío de mensajes en Amazon SQS (p. 96)• Envío y recepción de mensajes en Amazon SQS (p. 96)• Recepción de mensajes en Amazon SQS (p. 98)• Recepción de mensajes mediante el sondeo largo de Amazon SQS (p. 98)• Habilitar el sondeo largo en Amazon SQS (p. 99)• Recibir mensajes utilizando la clase QueuePoller en Amazon SQS (p. 100)• Redireccionamiento de mensajes fallidos en Amazon SQS (p. 102)• Eliminación de una cola en Amazon SQS (p. 102)• Habilitar un recurso para publicarlo en una cola de Amazon SQS (p. 102)• Trabajar con una cola de mensajes fallidos en Amazon SQS (p. 103)• Especificación del tiempo de espera de visibilidad de los mensajes en Amazon SQS (p. 105)

Obtener información acerca de todas las colas enAmazon SQSEn el siguiente ejemplo se muestran las URL, los ARN, los mensajes disponibles y los mensajes entránsito de las colas de Amazon SQS en la región us-west-2.

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

queues = sqs.list_queues

queues.queue_urls.each do |url| puts 'URL: ' + url

# Get ARN, messages available, and messages in flight for queue req = sqs.get_queue_attributes( { queue_url: url, attribute_names: [ 'QueueArn', 'ApproximateNumberOfMessages', 'ApproximateNumberOfMessagesNotVisible' ] } )

arn = req.attributes['QueueArn'] msgs_available = req.attributes['ApproximateNumberOfMessages']

94

Page 100: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideCreación de una cola en Amazon SQS

msgs_in_flight = req.attributes['ApproximateNumberOfMessagesNotVisible']

puts 'ARN: ' + arn puts 'Messages available: ' + msgs_available puts 'Messages in flight: ' + msgs_in_flight putsend

Creación de una cola en Amazon SQSEn el siguiente ejemplo se crea la cola de Amazon SQS MyGroovyQueue en la región us-west-2 y semuestra su URL.

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

queue = sqs.create_queue(queue_name: 'MyGroovyQueue')

puts queue.queue_url

Uso de colas en Amazon SQSAmazon SQS ofrece colas alojadas altamente escalables para almacenar los mensajes que se transfierenentre aplicaciones o microservicios. Para obtener más información acerca de las colas, consulte Cómofuncionan las colas de Amazon SQS.

En este ejemplo, va a utilizar AWS SDK for Ruby con Amazon SQS para:

1. Obtenga una lista de las colas mediante Aws::SQS::Client#list_queues.2. Cree una cola mediante Aws::SQS::Client#create_queue.3. Obtenga la URL de la cola mediante Aws::SQS::Client#get_queue_url.4. Elimine la cola mediante Aws::SQS::Client#delete_queue.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

Ejemplorequire 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-east-1')

# Get a list of your queues.sqs.list_queues.queue_urls.each do |queue_url| puts queue_urlend

# Create a queue.queue_name = "my-queue"

95

Page 101: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEnvío de mensajes en Amazon SQS

begin sqs.create_queue({ queue_name: queue_name, attributes: { "DelaySeconds" => "60", # Delay message delivery for 1 minute (60 seconds). "MessageRetentionPeriod" => "86400" # Delete message after 1 day (24 hours * 60 minutes * 60 seconds). } })rescue Aws::SQS::Errors::QueueDeletedRecently puts "A queue with the name '#{queue_name}' was recently deleted. Wait at least 60 seconds and try again." exit(false)end

# Get the queue's URL.queue_url = sqs.get_queue_url(queue_name: queue_name).queue_urlputs queue_url

# Delete the queue.sqs.delete_queue(queue_url: queue_url)

Envío de mensajes en Amazon SQSEn el siguiente ejemplo se envía el mensaje "Hello world" a través de la cola de Amazon SQS con la URLURL en la región us-west-2.

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

sqs.send_message(queue_url: URL, message_body: 'Hello world')

En el siguiente ejemplo se envían los mensajes "Hello world" y "How is the weather?" a través de la cola deAmazon SQS con la dirección URL URL en la región us-west-2.

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

resp = sqs.send_message_batch({ queue_url: URL, entries: [ { id: 'msg1', message_body: 'Hello world' }, { id: 'msg2', message_body: 'How is the weather?' } ],})

Envío y recepción de mensajes en Amazon SQSDespués de crear una cola en Amazon SQS, puede enviarle un mensaje y después consumirlo. Paraobtener más información, consulte Tutorial: Envío de un mensaje a una cola de Amazon SQS y Tutorial:Recepción y eliminación de un mensaje de una cola de Amazon SQS.

96

Page 102: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEnvío y recepción de mensajes en Amazon SQS

En este ejemplo, va a utilizar AWS SDK for Ruby con Amazon SQS para:

1. Enviar un mensaje a una cola existente utilizando Aws::SQS::Client#send_message.2. Recibir el mensaje en la cola de mensajes usando Aws::SQS::Client#receive_message.3. Mostrar información sobre el mensaje.4. Eliminar el mensaje de la cola de mensajes usando Aws::SQS::Client#delete_message.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También es necesario crear la cola my-queue, lo que puede hacer en la consola de Amazon SQS.

Ejemplo

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-east-1')

# Send a message to a queue.queue_name = "my-queue"

begin queue_url = sqs.get_queue_url(queue_name: queue_name).queue_url

# Create a message with three custom attributes: Title, Author, and WeeksOn. send_message_result = sqs.send_message({ queue_url: queue_url, message_body: "Information about current NY Times fiction bestseller for week of 2016-12-11.", message_attributes: { "Title" => { string_value: "The Whistler", data_type: "String" }, "Author" => { string_value: "John Grisham", data_type: "String" }, "WeeksOn" => { string_value: "6", data_type: "Number" } } })rescue Aws::SQS::Errors::NonExistentQueue puts "A queue named '#{queue_name}' does not exist." exit(false)end

puts send_message_result.message_id

# Receive the message in the queue.receive_message_result = sqs.receive_message({ queue_url: queue_url,

97

Page 103: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideRecepción de mensajes en Amazon SQS

message_attribute_names: ["All"], # Receive all custom attributes. max_number_of_messages: 1, # Receive at most one message. wait_time_seconds: 0 # Do not wait to check for the message.})

# Display information about the message.# Display the message's body and each custom attribute value.receive_message_result.messages.each do |message| puts message.body puts "Title: #{message.message_attributes["Title"]["string_value"]}" puts "Author: #{message.message_attributes["Author"]["string_value"]}" puts "WeeksOn: #{message.message_attributes["WeeksOn"]["string_value"]}"

# Delete the message from the queue. sqs.delete_message({ queue_url: queue_url, receipt_handle: message.receipt_handle })end

Recepción de mensajes en Amazon SQSEn el siguiente ejemplo se muestra el cuerpo de hasta 10 mensajes en la cola de Amazon SQS con la URLURL en la región us-west-2.

Note

receive_message no garantiza la obtención de todos los mensajes (consulte Properties ofDistributed Queues) y de forma predeterminada no elimina el mensaje.

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

resp = sqs.receive_message(queue_url: URL, max_number_of_messages: 10)

resp.messages.each do |m| puts m.bodyend

Recepción de mensajes mediante el sondeo largo deAmazon SQSEn el siguiente ejemplo se espera hasta 10 segundos para mostrar el cuerpo de hasta 10 mensajes en lacola de Amazon SQS con la URL URL en la región us-west-2.

Si no se especifica un tiempo de espera, el valor predeterminado es 0 (Amazon SQS no espera).

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

resp = sqs.receive_message(queue_url: URL, max_number_of_messages: 10, wait_time_seconds: 10)

resp.messages.each do |m| puts m.bodyend

98

Page 104: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideHabilitar el sondeo largo en Amazon SQS

Habilitar el sondeo largo en Amazon SQSEl sondeo largo ayuda a bajar el costo de usar Amazon SQS porque reduce el número de respuestasvacías y elimina las respuestas vacías falsas. Para obtener más información acerca del sondeo largo,consulte Sondeo largo de Amazon SQS.

En este ejemplo, va a utilizar AWS SDK for Ruby con Amazon SQS para:

1. Crear una cola y establecerla para sondeo largo utilizando Aws::SQS::Client#create_queue.2. Establecer el sondeo largo para una cola existente utilizando Aws::SQS::Client#set_queue_attributes.3. Establecer el sondeo largo cuando se reciben mensajes en una cola utilizando

Aws::SQS::Client#receive_message.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También es necesario crear las colas existing-queue y receive-queue, que puede hacer en la consola deAmazon SQS.

Ejemplorequire 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-east-1')

# Create a queue and set it for long polling.new_queue_name = "new-queue"

create_queue_result = sqs.create_queue({ queue_name: new_queue_name, attributes: { "ReceiveMessageWaitTimeSeconds" => "20" # Wait 20 seconds to receive messages. },}) puts create_queue_result.queue_url

# Set long polling for an existing queue.begin existing_queue_name = "existing-queue" existing_queue_url = sqs.get_queue_url(queue_name: existing_queue_name).queue_url

sqs.set_queue_attributes({ queue_url: existing_queue_url, attributes: { "ReceiveMessageWaitTimeSeconds" => "20" # Wait 20 seconds to receive messages. }, })rescue Aws::SQS::Errors::NonExistentQueue puts "Cannot set long polling for a queue named '#{existing_queue_name}', as it does not exist."end

99

Page 105: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideRecibir mensajes utilizando la clase

QueuePoller en Amazon SQS

# Set long polling when receiving messages for a queue.

# 1. Using receive_message.begin receive_queue_name = "receive-queue" receive_queue_url = sqs.get_queue_url(queue_name: receive_queue_name).queue_url

puts "Begin receipt of any messages using receive_message..." receive_message_result = sqs.receive_message({ queue_url: receive_queue_url, attribute_names: ["All"], # Receive all available built-in message attributes. message_attribute_names: ["All"], # Receive any custom message attributes. max_number_of_messages: 10 # Receive up to 10 messages, if there are that many. })

puts "Received #{receive_message_result.messages.count} message(s)."rescue Aws::SQS::Errors::NonExistentQueue puts "Cannot receive messages using receive_message for a queue named '#{receive_queue_name}', as it does not exist."end

# 2. Using Aws::SQS::QueuePoller.begin puts "Begin receipt of any messages using Aws::SQS::QueuePoller..." puts "(Will keep polling until no more messages available for at least 60 seconds.)" poller = Aws::SQS::QueuePoller.new(receive_queue_url)

poller_stats = poller.poll({ max_number_of_messages: 10, idle_timeout: 60 # Stop polling after 60 seconds of no more messages available (polls indefinitely by default). }) do |messages| messages.each do |message| puts "Message body: #{message.body}" end end # Note: If poller.poll is successful, all received messages are automatically deleted from the queue.

puts "Poller stats:" puts " Polling started at: #{poller_stats.polling_started_at}" puts " Polling stopped at: #{poller_stats.polling_stopped_at}" puts " Last message received at: #{poller_stats.last_message_received_at}" puts " Number of polling requests: #{poller_stats.request_count}" puts " Number of received messages: #{poller_stats.received_message_count}"rescue Aws::SQS::Errors::NonExistentQueue puts "Cannot receive messages using Aws::SQS::QueuePoller for a queue named '#{receive_queue_name}', as it does not exist."end

Recibir mensajes utilizando la clase QueuePoller enAmazon SQSEn el siguiente ejemplo se utiliza la clase QueuePoller para mostrar el cuerpo de todos los mensajes dela cola de SQS con la dirección URL URL en la región us-west-2 y se elimina el mensaje. Después de 15segundos de inactividad aproximadamente, el tiempo de espera del script finaliza.

require 'aws-sdk'

Aws.config.update({region: 'us-west-2'})

poller = Aws::SQS::QueuePoller.new(URL)

100

Page 106: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideRecibir mensajes utilizando la clase

QueuePoller en Amazon SQS

poller.poll(idle_timeout: 15) do |msg| puts msg.bodyend

En el siguiente ejemplo se realiza un bucle en la cola de Amazon SQS con la URL URLy se espera hastaque trascurran los segundos de duración.

Puede obtener la URL correcta ejecutando el ejemplo de Amazon SQS incluido en Obtener informaciónacerca de todas las colas en Amazon SQS (p. 94).

require 'aws-sdk'

Aws.config.update({region: 'us-west-2'})

poller = Aws::SQS::QueuePoller.new(URL)

poller.poll(wait_time_seconds: duration, idle_timeout: duration + 1) do |msg| puts msg.bodyend

En el siguiente ejemplo se realiza un bucle en la cola de Amazon SQS con la dirección URL URL y seofrecen los segundos del tiempo de espera de visibilidad para procesar el mensaje, representado por elmétodo do_something.

require 'aws-sdk'

# Process the messagedef do_something(msg) puts msg.bodyend

Aws.config.update({region: 'us-west-2'})

poller = Aws::SQS::QueuePoller.new(URL)

poller.poll(timeout_visibility: timeout, idle_timeout: timeout + 1) do |msg| do_something(msg)end

En el siguiente ejemplo se realiza un bucle en la cola de Amazon SQS con la URL URL y se cambian lossegundos del tiempo de espera de visibilidad para los mensajes que necesiten procesamiento adicionalpor el método do_something2.

require 'aws-sdk'

# Process the messagedef do_something(msg) trueend

# Do additional processingdef do_something2(msg) puts msg.bodyend

Aws.config.update({region: 'us-west-2'})

poller = Aws::SQS::QueuePoller.new(URL)

poller.poll(idle_timeout: timeout + 1) do |msg|

101

Page 107: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideRedireccionamiento de mensajes fallidos en Amazon SQS

if do_something(msg) # need more time for processing poller.change_message_visibility_timeout(msg, timeout)

do_something2(msg) endend

Redireccionamiento de mensajes fallidos en AmazonSQSEn el siguiente ejemplo, todos los mensajes fallidos de la cola con la URL URL se redirigen a la cola con elARN ARN.

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

sqs.set_queue_attributes({ queue_url: URL, attributes: { 'RedrivePolicy' => "{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\"#{ARN}\"}" }})

Eliminación de una cola en Amazon SQSEn el siguiente ejemplo se elimina la cola de Amazon SQS con la URL URL en la región us-west-2.

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

sqs.delete_queue(queue_url: URL)

Habilitar un recurso para publicarlo en una cola deAmazon SQSEn el siguiente ejemplo se habilita el recurso con el ARN my-resource-arn para publicarlo en la colacon el ARN my-queue-arn y la URL my-queue-url en la región us-west-2.

require 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-west-2')

policy = '{ "Version":"2008-10-17", "Id":' + my-queue-arn + '/SQSDefaultPolicy", "Statement":[{ "Sid":"__default_statement_ID", "Effect":"Allow", "Principal":{ "AWS":"*" }, "Action":["SQS:SendMessage"],

102

Page 108: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTrabajar con una cola de mensajes fallidos en Amazon SQS

"Resource":"' + my-queue-arn + '", "Condition":{ "ArnEquals":{ "AWS:SourceArn":"' + my-resource-arn + '"} } }]}'

sqs.set_queue_attributes({ queue_url: my-queue-url, attributes: { Policy: policy }})

Trabajar con una cola de mensajes fallidos en AmazonSQSAmazon SQS añade compatibilidad para las colas de mensajes fallidos. Una cola de mensajes fallidos esuna cola a la que otras colas pueden enviar mensajes que no se pueden procesar correctamente. Puedeapartar y aislar estos mensajes en la cola de mensajes fallidos para determinar por qué no se procesaroncorrectamente. Para obtener más información las colas de mensajes fallidos, consulte Using Amazon SQSDead Letter Queues.

En este ejemplo, va a utilizar AWS SDK for Ruby con Amazon SQS para:

1. Cree una cola que represente una cola de mensajes fallidos usando Aws::SQS::Client#create_queue.2. Asocie la cola de mensajes fallidos a una cola existente utilizando

Aws::SQS::Client#set_queue_attributes.3. Envíe un mensaje a la cola existente utilizando Aws::SQS::Client#send_message.4. Sondee la cola utilizando Aws::SQS::QueuePoller.5. Reciba mensajes en la cola de mensajes fallidos usando Aws::SQS::Client#receive_message.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

Asimismo, necesitará utilizar la Consola de administración de AWS para crear la cola my-queue.

Nota: para simplificar, el código de ejemplo siguiente no demuestra Aws::SQS::Client#add_permission. Enun escenario real, debe siempre restringir el acceso a acciones como SendMessage, ReceiveMessage,DeleteMessage y DeleteQueue. No hacerlo podría provocar la revelación de información, la denegación deservicio o la inyección de mensajes en las colas.

Ejemplo

require 'aws-sdk'

# Uncomment for Windows.# Aws.use_bundled_cert!

103

Page 109: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideTrabajar con una cola de mensajes fallidos en Amazon SQS

sqs = Aws::SQS::Client.new(region: 'us-east-1')

# Create a queue representing a dead letter queue.dead_letter_queue_name = "dead-letter-queue"

sqs.create_queue({ queue_name: dead_letter_queue_name})

# Get the dead letter queue's URL and ARN, so that you can associate it with an existing queue.dead_letter_queue_url = sqs.get_queue_url(queue_name: dead_letter_queue_name).queue_url

dead_letter_queue_arn = sqs.get_queue_attributes({ queue_url: dead_letter_queue_url, attribute_names: ["QueueArn"]}).attributes["QueueArn"]

# Associate the dead letter queue with an existing queue.begin queue_name = "my-queue" queue_url = sqs.get_queue_url(queue_name: queue_name).queue_url

# Use a redrive policy to specify the dead letter queue and its behavior. redrive_policy = { "maxReceiveCount" => "5", # After the queue receives the same message 5 times, send that message to the dead letter queue. "deadLetterTargetArn" => dead_letter_queue_arn }.to_json

sqs.set_queue_attributes({ queue_url: queue_url, attributes: { "RedrivePolicy" => redrive_policy } })

rescue Aws::SQS::Errors::NonExistentQueue puts "A queue named '#{queue_name}' does not exist." exit(false)end

# Send a message to the queue.puts "Sending a message..."

sqs.send_message({ queue_url: queue_url, message_body: "I hope I get moved to the dead letter queue."})

30.downto(0) do |i| print "\rWaiting #{i} second(s) for sent message to be receivable..." sleep(1)end

puts "\n"

poller = Aws::SQS::QueuePoller.new(queue_url)# Receive 5 messages max and stop polling after 20 seconds of no received messages.poller.poll(max_number_of_messages:5, idle_timeout: 20) do |messages| messages.each do |msg| puts "Received message ID: #{msg.message_id}" endend

104

Page 110: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEspecificación del tiempo de espera de

visibilidad de los mensajes en Amazon SQS

# Check to see if Amazon SQS moved the message to the dead letter queue.receive_message_result = sqs.receive_message({ queue_url: dead_letter_queue_url, max_number_of_messages: 1})

if receive_message_result.messages.count > 0 puts "\n#{receive_message_result.messages[0].body}"else puts "\nNo messages received."end

Especificación del tiempo de espera de visibilidad delos mensajes en Amazon SQSEn Amazon SQS, inmediatamente después de recibirse un mensaje, este permanece en la cola. Paraevitar que otros consumidores procesen el mensaje de nuevo, Amazon SQS establece un tiempo deespera de visibilidad. Se trata de un periodo de tiempo durante el cual Amazon SQS impide que otroscomponentes consumidores reciban y procesen el mensaje. Para obtener más información, consulteTiempo de espera de visibilidad.

En este ejemplo, va a utilizar AWS SDK for Ruby con Amazon SQS para:

1. Obtenga la URL de una cola existente mediante Aws::SQS::Client#get_queue_url.2. Reciba hasta 10 mensajes mediante Aws::SQS::Client#receive_message.3. Especifique el intervalo de tiempo durante el cual los mensajes no son visibles después de recibirse

mediante Aws::SQS::Client#change_message_visibility.

Requisitos previosAntes de ejecutar el código de ejemplo, debe instalar y configurar AWS SDK for Ruby, tal y como sedescribe en:

• Instalación de AWS SDK para Ruby (p. 4)• Configuración de AWS SDK para Ruby (p. 5)

También es necesario crear la cola my-queue, lo que puede hacer en la consola de Amazon SQS.

Ejemplorequire 'aws-sdk'

sqs = Aws::SQS::Client.new(region: 'us-east-1')

begin queue_name = "my-queue" queue_url = sqs.get_queue_url(queue_name: queue_name).queue_url

receive_message_result_before = sqs.receive_message({ queue_url: queue_url, max_number_of_messages: 10 # Receive up to 10 messages, if there are that many. })

puts "Before attempting to change message visibility timeout: received #{receive_message_result_before.messages.count} message(s)."

105

Page 111: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideEspecificación del tiempo de espera de

visibilidad de los mensajes en Amazon SQS

receive_message_result_before.messages.each do |message| sqs.change_message_visibility({ queue_url: queue_url, receipt_handle: message.receipt_handle, visibility_timeout: 36000 # This message will not be visible for 10 hours (10 hours * 60 minutes * 60 seconds) after first receipt. }) end

# Try to retrieve the original messages after setting their visibility timeout. receive_message_result_after = sqs.receive_message({ queue_url: queue_url, max_number_of_messages: 10 })

puts "\nAfter attempting to change message visibility timeout: received #{receive_message_result_after.messages.count} message(s)."

rescue Aws::SQS::Errors::NonExistentQueue puts "Cannot receive messages for a queue named '#{receive_queue_name}', as it does not exist."end

106

Page 112: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer GuideSugerencias y trucos para Amazon EC2

Consejos y trucos para AWS SDK forRuby

En esta sección se proporcionan consejos y trucos sobre el uso de AWS SDK for Ruby con los servicios deAWS.

Temas• Sugerencias y trucos para Amazon EC2 (p. 107)

Sugerencias y trucos para Amazon EC2Esta sección proporciona algunos consejos para ayudar a AWS SDK for Ruby con los servicios de AmazonElastic Compute Cloud (Amazon EC2). Para obtener más información acerca de Amazon EC2, consulte laGuía de introducción de Amazon EC2.

Cambio de IP elásticasEn el siguiente ejemplo se asocia la dirección IP elástica a la instancia representada por i-12345678.

ec2 = Aws::EC2::Client.new

resp = ec2.allocate_addressec2.associate_address(instance_id:"i-12345678", allocation_id: resp.allocation_id)

107

Page 113: AWS SDK parar Ruby...AWS SDK parar Ruby Developer Guide Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner

AWS SDK parar Ruby Developer Guide

Historial de revisiónPara ver la lista de cambios en AWS SDK for Ruby y su documentación, consulte el archivoCHANGELOG.md en el repositorio aws/aws-sdk-ruby de GitHub.

108