Amazon Elastic Compute Cloud (EC2) é a plataforma base para o ambiente de computação
em nuvem fornecido pelo Amazon. EC2 facilita a criação, a ativação e a provisão de
instâncias virtuais – a qualquer momento – para as suas necessidades
pessoais ou comerciais.
Você paga por essas instâncias com base no tipo de instância
e no seu uso por hora real. Os servidores virtuais são executados dentro do ambiente
seguro dos próprios datacenters do Amazon.
O EC2 pode proporcionar aos seus aplicativos da Web a capacidade de:
- Configurar os requisitos de computação instantaneamente
- Ajustar a capacidade com base na demanda
Mas que proposta mais valiosa no atual mundo voltado à Web, em que o tráfego pode
chegar a níveis muito altos se o site for mencionado na primeira página do Google – e uma hora depois cair bastante. Agora, é possível aumentar ou diminuir a
capacidade de maneira elástica. Alguns recursos valiosos fornecidos por esse novo
modelo de computação elástica:
- Confiabilidade: O EC2 foi projetado para facilmente fornecer instâncias e destruí-las quando não
forem mais necessárias. - Simplicidade: Criado com base em conceitos simples, o EC2 fornece a flexibilidade para que
você arquitete os seus sistemas. O Amazon fornece todos os blocos de construção
de que você precisa. Ainda é possível combiná-los de modo a corresponder aos casos de
uso de aplicativo. - Segurança: O EC2 foi projetado para fornecer um alto nível de segurança. Todas as
instâncias são executadas dentro dos datacenters seguros do Amazon, com a
capacidade de configurar regras de firewall para restringir todo o acesso a
grupos de sua confiança. - Resiliência: É possível criar resiliência nos aplicativos colocando suas instâncias em
localidades diferentes e usando volumes de armazenamento persistente cujo ciclo
de vida é independente de uma instância mais efêmera. - Baixo custo: O serviço EC2 é cobrado em taxas que o tornam uma alternativa muito econômica e
atraente para todas as suas necessidades de servidor.
A estrutura do Amazon EC2
Esta seção explora os conceitos que sustentam a estrutura do EC2.
Amazon Machine Images
Amazon Machine Images (AMIs) são ambientes de servidor em pacote baseados em
Linux que podem executar qualquer software ou aplicativo desejado. Eles são o
coração do ambiente de computação elástico fornecido pelo EC2.
O release atual do
EC2 suporta AMIs com base em Linux, embora exista também algum suporte inicial para
usar OpenSolaris no sistema operacional no ambiente EC2.
Há três tipos de imagens de máquina:
Tabela 1: Tipos de máquina
| Tipo | Definição |
|---|---|
| Privado | Imagens criadas por você, que são particulares por padrão. É possível conceder acesso a outros usuários para iniciar suas imagens privadas. |
| Público | Imagens criadas pelos usuários e liberadas para a comunidade do Amazon Web Services, para que qualquer pessoa possa iniciar instâncias com base nelas e usá-las da forma que desejar. O Amazon Web Services Developer Connection lista todas as imagens públicas. |
| Pago | É possível criar imagens fornecendo funções específicas que podem ser iniciadas por qualquer pessoa que queira pagá-lo por hora de uso com base nas taxas do Amazon. |
O Amazon fornece várias ferramentas de linha de comando que facilitam a criação e o
gerenciamento de imagens de máquina. As próprias imagens são armazenadas no Amazon
Simple Storage Service (S3).
Após o registro da imagem com EC2, um ID exclusivo é
atribuído à imagem, que pode ser usado para identificá-la e iniciar uma instância a
partir dela. Há várias formas de criar sua própria imagem.
É possível usar uma
imagem pública existente como base para suas próprias imagens e use o seguinte fluxo
de trabalho para criar uma nova AMI:
- Inicie uma instância a partir da AMI existente com o seu par de chaves de shell
de soquete seguro (SSH) - SSH na instância
- Customize a instância como quiser
- Crie novamente o pacote configurável da instância em execução em uma nova AMI
usando as ferramentas do Amazon - Carregue o pacote configurável no S3 para armazenamento usando as ferramentas
do Amazon - Registre essa nova imagem com o EC2 usando as ferramentas do Amazon
- Inicie uma nova instância a partir dessa nova imagem e repita a customização e
a recriação do pacote configurável até estar satisfeito com o resultado
Outra opção é criar uma nova AMI usando um dos scripts disponíveis publicamente na
comunidade do EC2. Os scripts permitem criar uma AMI do zero. Scripts populares –
scripts de criação de AMI baseados em:
- Ubuntu e Debian fornecidos por Eric Hammond. É
possível usar as imagens criadas previamente a partir do seu site ou criar uma
do zero com os scripts. - Se você estiver procurando imagens que servem como a base para os aplicativos
Ruby on Rails, Paul Dowman
fornece um script que pode criar uma imagem baseada em Ubuntu de aplicativos em
execução no EC2. - RightScale fornece scripts baseados em Ubuntu e CentOS para a criação de imagens do
zero.
Instâncias
Instâncias são as instâncias virtuais em execução que usam uma AMI como
modelo. É possível iniciar uma instância, visualizar detalhes sobre a instância e
encerrá-la usando as ferramentas fornecidas pelo Amazon. É possível também usar uma
variedade de bibliotecas de terceiros em diferentes linguagens para controlar o
ciclo de vida das instâncias.
As instâncias podem ter como base plataformas de 32 ou 64 bits e ser de um dos
seguintes tipos. O Amazon também classifica cada tipo de instância em termos de
unidades de cálculo de EC2.
Cada unidade de cálculo de EC2 (ECU) fornece a
capacidade de processador equivalente de um processador Opteron 2007 de 1 – 1,2 GHz
ou Intel Xeon 2007. Confira os preços para
mais detalhes sobre cada tipo de instância.
- Instância pequena (m1.small): 1,7 GB de memória, 1 unidade de cálculo EC2 (1 núcleo virtual com 1 unidade de
cálculo EC2), armazenamento de instância de 160 GB, plataforma de 32 bits,
desempenho de E/S moderado. - Instância grande (m1.large): memória de 7,5 GB, 4 unidades de cálculo EC2 (2 núcleos virtuais, cada um com 2
unidades de cálculo EC2), armazenamento de instância de l850 GB, plataforma de
64 bits, alto desempenho de E/S. - Instância extragrande (m1.xlarge): memória de 15 GB, 8 unidades de cálculo EC2 (4 núcleos virtuais, cada um com 2
unidades de cálculo EC2), armazenamento de instância de 1690 GB, plataforma de
64 bits, alto desempenho de E/S. - Instância média (c1.medium): 1,7 GB de memória, 5 unidades de cálculo EC2 (2 núcleos virtuais com 2,5
unidades de cálculo EC2), armazenamento de instância de 350 GB, plataforma de 32
bits, desempenho de E/S moderado. - Instância extragrande (c1.xlarge): Memória de 7 GB, 20 unidades de cálculo EC2 (8 núcleos virtuais, cada um com
2.5 unidades de cálculo EC2), armazenamento de instância de 1690 GB, plataforma
de 64 bits, alto desempenho de E/S.
Como as instâncias são cobradas com base no tempo real de uso, é possível dimensionar
as necessidades de computação facilmente com base na carga atual do aplicativo. Não
é preciso ter a capacidade antecipadamente.
Grupos de segurança
Toda e qualquer instância iniciada no ambiente EC2 é executada dentro de um grupo de
segurança. Cada grupo de segurança define as regras de firewall que especificam as
restrições de acesso para instâncias executadas dentro desse grupo.
É possível
conceder ou restringir o acesso por endereço IP ou regras classless interdomain
routing (CIDR), que permitem especificar um intervalo de portas e o protocolo de
transporte.
Também é possível controlar o acesso a grupos de segurança
especificados, para que qualquer instância em execução nesses grupos de acesso de
segurança tenha acesso automaticamente concedido ou negado à instância.
Pares de chave de segurança
Os pares de chave de segurança são pares de chave SSH públicos/privados especificados
na ativação de uma instância. Eles são necessários para na verdade fazer login no
console de uma de suas instâncias ativadas. O EC2 adicionará a parte pública do par
de chaves à instância ativada e será possível usar a chave privada para ssh nele.
Os pares de chave de segurança são diferentes do ID da chave de acesso e da chave de
segurança do Amazon Web Services (disponíveis na página de dados da conta), que são usados para identificar você
exclusivamente como o usuário que faz as solicitações ao Amazon Web Services usando
a API.
Os pares de chave de segurança são principalmente para permitir que os
usuários façam login com segurança em instâncias sem a necessidade do uso de
senhas.
Zonas de disponibilidade
O EC2 é composto por vários datacenters em localidades separadas para fornecer
resiliência à falhas. É possível colocar as instâncias ativadas em locais
diferentes. Os locais são regiões geográficas com zonas de disponibilidade dentro
delas.
O release atual do EC2 fornece acesso a uma única região no leste dos Estados
Unidos com três zonas de disponibilidade dentro dela. Cada zona de disponibilidade
dentro de uma região foi projetada pelo Amazon para isolamento contra falhas em
outras zonas de disponibilidade.
É possível proteger seus aplicativos contra a falha de um único local ativando
instâncias em zonas de disponibilidade separadas. Se você não especificar uma zona
de disponibilidade ao iniciar uma instância, o Amazon escolherá automaticamente uma
para você com base no funcionamento do sistema e na capacidade atuais.
Endereços IP elásticos
A cada instância é atribuída automaticamente um endereço IP privado e um público na
ativação pelo EC2. O endereço IP público pode ser usado para acessar a
instância pela Internet. Entretanto, sempre que você ativar uma instância, esse
endereço mudará.
Se você estiver usando qualquer tipo de mapeamento de DNS dinâmico
para conectar um nome DNS ao endereço IP, a alteração poderá levar até 24 horas para
ser propagada pela Internet. O EC2 apresentou o conceito de um endereço IP elástico
para aliviar esse problema.
Cada endereço IP elástico é associado à sua conta do EC2
e não a uma instância específica e será associado permanentemente à conta, a menos
que você explicitamente o libere novamente para EC2.
É possível também remapear um endereço IP elástico entre instâncias e dessa forma
responder rapidamente a qualquer falha de instância apenas iniciando outra instância
e remapeando-a (ou usando uma instância existente). A qualquer momento, é possível
apenas ter uma única instância mapeada para um endereço IP elástico.
Elastic Block Store (EBS)
EBS é uma nova forma de armazenamento persistente criada pelo Amazon que permite
criar volumes que possam ser anexados como dispositivos em nível de bloco a uma
instância em execução.
É possível também criar capturas instantâneas a partir desses
volumes e depois recriar um volume a partir da captura instantânea. Cada captura
instantânea representa o estado de um volume em um ponto específico no tempo. Dessa
forma, é possível armazenar facilmente arquivos e dados que precisam persistir além
do tempo de vida de uma instância em um volume EBS e depois facilmente anexar e
reanexar esse volume a qualquer instância desejada.
A única advertência é que cada volume EBS pode ser anexado a uma instância por vez.
Entretanto, é possível anexar o número desejado de volumes diferentes a uma única
instância.
Cada volume EBS é associado e está localizado em uma zona de
disponibilidade. A instância a que o volume está sendo anexado deve estar na mesma
zona de disponibilidade. Há um limite de conta de 20 volumes EBS, mas é possível solicitar que o Amazon Web Services aumente o limite se for preciso usar
mais volumes.
Preços
Os encargos para EC2 são calculados com base em quatro critérios:
- O tipo de instância usado. Há dois tipos padrão de instâncias, cada um com um
número variável de núcleos, memória, armazenamento e arquitetura.
- Padrão: Instâncias normais que podem ser usadas para a maioria dos
aplicativos.
- CPU potente: Instâncias mais adequadas para aplicativos que precisam de muita
potência de processador e utilizam recursos de computação intensamente.
A Tabela 2 mostra a precificação de exemplo de tipos de instância de
pequenos a grandes.
Tabela 2. Precificação de tipo de instância
| Tipo | Detalhes | Custo |
|---|---|---|
| Pequeno padrão | 1,7 GB de memória, 1 unidade de cálculo EC2, 160 GB de armazenamento, plataforma de 32 bits |
$0,10 por instância-hora |
| Grande padrão | 7,5 GB de memória, 4 unidades de cálculo EC2, 850 GB de armazenamento, plataforma de 64 bits |
$0,40 por instância-hora |
| Padrão extragrande | 15 GB de memória, 8 unidades de cálculo EC2, 1.690 GB de armazenamento, plataforma de 64 bits |
$0,80 por instância-hora |
| CPU potente média | 1,7 GB de memória, 5 unidades de cálculo EC2, 35 GB de armazenamento, plataforma de 32 bits |
$0,20 por instância-hora |
| CPU potente extragrande | 7 GB de memória, 20 unidades de cálculo EC2, 1.690 GB de armazenamento, plataforma de 32 bits |
$0,80 por instância-hora |
02. A quantidade de dados ou largura de banda transferida para e do EC2. Não há
nenhum encargo para dados transferidos entre os depósitos EC2, SimpleDB e S3
localizados nos Estados Unidos. Os dados transferidos entre os depósitos EC2 e
S3 europeu são cobrados nas taxas de transferência de dados padrão.
Tabela 3. Precificação de transferência de dados
| Tipo de transferência | Custo |
|---|---|
| Transferência de dados pela Internet | $0,100 por GB — transferência entrada de todos os dados $0,170 por GB — |
| Transferência entre zona de dados de disponibilidade |
$0,00 por GB — transferência de todos os dadosentre instâncias na mesma zona de dados $0,01 por GB — transferência de todos os |
| Transferência de dados IP pública e elástica |
$0,01 por GB — transferência de entrada/de saída de todos os dados |
| Transferência de dados IP privados | $0,00 por GB — transferência de entrada/de saída de todos os dados |
03. O armazenamento usado pelas capturas instantâneas e pelos volumes EBS.
Tabela 4. Precificação para EBS
| Tipo | Custo |
|---|---|
| Volumes EBS | $0,10 por GB/mês
$0,10 por 1 |
| Capturas instantâneas EBS | $0,15 por GB/mês
$0,01 por $0,01 por 10.000 solicitações GET para carregar capturas |
04. O número de endereços IP elásticos alocados a você que não foram usados.
Tabela 5. Precificação para endereços IP elásticos
| Tipo | Custo |
|---|---|
| IP elástico | Nenhum custo para endereços IP elásticos enquanto em uso $ 0,01 por endereço IP elástico não $0,00 por remapeamento de |
Marque Amazon EC2 para a precificação mais recente. É
possível também usar Amazon Web Services Calculadora mensal
simples para calcular seus custos de uso mensais para EC2 e os outros Amazon
Web Services.
Primeiros passos com o EC2
Par a começar a explorar o EC2, é preciso primeiro criar uma conta Amazon Web Services. A Parte
2 desta série tem instruções detalhadas para criar uma conta Amazon Web
Services.
Quando você tiver uma conta, será preciso ativar o serviço Amazon EC2 para
a sua conta usando as seguintes etapas:
- Faça login na sua conta Amazon Web Services.
- Navegue para Amazon EC2.
- Selecione Sign Up For This Web Service no lado direito da página.
- Forneça as informações solicitadas e finalize o processo de inscrição.
Toda comunicação com qualquer um dos Amazon Web Services será por meio da interface
SOAP ou da interface query/REST. Neste artigo, você usará a interface query/REST
para se comunicar com o EC2.
É preciso obter suas chaves de acesso, que podem ser
acessadas pela página de dados da conta de serviços da Web, selecionando View Access
Key Identifiers. Você está agora configurado para usar Amazon Web Services e ativou o serviço EC2
para a sua conta.
Interagindo com o EC2
Para este exemplo, você precisará usar as ferramentas de linha de comando fornecidas
pelo Amazon e uma biblioteca Ruby de terceiros de software livre denominada right_aws para interagir com EC2. Por meio deste artigo,
você irá:
- Configurar um ambiente de desenvolvimento EC2 local.
- Ativar uma AMI existente.
- Customizar a AMI para instalar a biblioteca right_aws e outros softwares necessários.
- Criar novamente o pacote configurável da AMI, carregar a AMI em S3 e
registrá-la. - Iniciar a nova AMI customizada.
- Familiarizar-se com a API right_aws executando
pequenos fragmentos de código em um shell Ruby.
Configurar um ambiente de desenvolvimento EC2 local
As ferramentas do Amazon EC2 exigem que você tenha a tecnologia Java, portanto, verifique se ela está instalada.
- Faça o download de Amazon EC2 AMI Tools e Amazon EC2 API Tools.
- Descompacte os arquivos das ferramentas no diretório de sua escolha.
- É preciso configurar algumas variáveis de ambiente e adicionar o diretório das
ferramentas ao caminho do shell para que você possa encontrá-las ao executar a
partir da linha de comando. A Listagem 1 mostra um exemplo.
Os comandos
abaixo são especificados para Linux. Se estiver usando o Microsoft
Windows, será possível substituir os comandos equivalentes. É possível
fazer o download do certificado EC2 X.509 e do seu arquivo-chave privado EC2
da página de dados da conta.
Listagem 1. Configurar o ambiente de desenvolvimento EC2
$ export EC2_HOME=path_to_the_directory_with_the_tools
$ export JAVA_HOME=path_to_the_directory_with_your_java_sdk
# Add the directory to your PATH
$ export PATH=$PATH:$EC2_HOME/bin
# Export variables with the paths to your private key file and X.509 certificate
$ export EC2_PRIVATE_KEY=path_to_your_private_key
$ export EC2_CERT=path_to_your_x509_certificate
04. Certifique-se de que tudo esteja configurado corretamente executando o comando
mostrado abaixo para listar a versão das ferramentas de linha de comando do seu
EC2.
Listagem 2. Verificar a configuração
$ ec2-ami-tools-version
1.3-20041 20071010
05. É preciso criar um par de chaves SSH a ser usado para ativar uma instância e
estabelecer conexão com ele no shell de linha de comando. O seguinte comando na
Listagem 3 cria um novo par de chaves e subsequentemente imprime o nome do par
de chaves, sua impressão digital e os dados de chave privada na tela.
Listagem 3. Criar um novo par de chaves SSH
$ ec2-add-keypair devworks
KEYPAIR devworks 29:d1:90:7b:3d:a4:99:52:41:e0:1f:21:d5:20:97:d3:f0:33:fd:76
-----BEGIN RSA PRIVATE KEY-----
MIIEowIBAAKCAQEAyxaeXt6nb+qzboVW/3ax7An8CUJjDqwNi/PZm4lGOAzOHGnuPlDXeh1GpJ9f
hky7Bg6VEY2VfS5G6UtmIzsGf/JlquzVl/x3uyriOzeCIw+m07aSgUOBn3qW/74IZxYYkxCYdBci
eZeKpr8Mpvuz2sfurRzQOkUeHyuEaiD1RRS7DGxxUXfpVYhGjPltfNW2xRSMLTaOZzRwRdS0cHUU
hC+GOKFDkp8nqQpd8iGUtp2G2DI1pxRN4MbeFZHWMh5tcIo1NTc7pkFPGEwrq6pO6gIsEOLqGpTL
+2AxJY5WToZQoTWieOVwLpjJU9fnufRs0Mt/M/TP6SGK/YkrQOprOwIDAQABAoIBAFj1UGvX9dnl
IbHAwInoUSlGelsH9GIB5XEvYFtr9xEoMsRpdk1flfNMjZwgn3Qxeh6+Fnf438lUkwUv3M6D1WYI
JJaJZUpM8ZlPwIcV2nBHM9k6+NOcYVQdG7VsZTvahusscssvMw+13KsLtpwSVwb3WsoDfAZ6LiaT
Jk5in20hTiipC0pz0K9DgQ//76r20ysUFpCymj4EvQrRkk5kBtsiMixsJzimpUOrSmrRHcORKEin
FKM6y/DFE33zhP8BNDQRaDLGni0Ip+/jP3EHmia41SSbnwzRcbXMfH5fL3KAyRsCE0ocHY+cjUng
HPYxl1ffdLZuEW3wJDQFuTS/v4ECgYEA9r7HVVnrS2303zclzCTGen/W/SVbpflSKEYJOZpa8RtQ
uFMOewfkTbBzfavLMVBYB8uAmcWIz5JAFSzlBaKDRCnouUeeDiDJVJd8Asbn1gCE8UVETUOthy50
R90RTtPNMmyP7AnoSMTuzsbwVORus7IJvceWHQBB4KCh652UansCgYEA0rSmvdquidkXf5iFpebc
6Wh/qy+L1dkgz7+HTZIMW7kxA4EfJFnqaQRPqJ5XYcLvk2IzxNQKJlZvtBhCfVYhPJ2uB2Yqxv0p
0LXGC01fZSyhbYGfaxVymA3HMc2ULBbaFMyhO7l7zkz+G+qkylych59zJBSoUxSFStpgNL7NhkEC
gYAPJIorLMeJ64eZo1LIgoFDx1C0XHSRbQmjuxiZ1mU6YsjDZyV+W2+hbPDJh5+CuUGNyOlthnfs
9TbFlenAPMb9iezkYgbLKyvv6xQLP5W+xm1iOTQF4d9mam1sc566TblMHOmAPONqg9t8CS16qEI6
+PQsF3GY+gkQ9gq54QPYvQKBgDgwjsrQd30xVI/lV7a/Uyg3gtxe6JaVuadNN0LbcMpBH64EkA58
oANzb97SoxDiEEuog4+40CAbKtzHH2wXPPPSROeaOkwolS8gWnkHICp19XKjf6Tp6k5cVkOUxC/h
xDSJwXGQ7FA+vgEp2NpSSjfssKLtk1ncfhNRGxjVzS9BAoGBALbBLS4Nbjs2Fco+okNQPNfJNSvW
yWV7a6ngfRzW8B+BO6V1QRIR44bwv/Z74oQ7ttt8KoZENB5yzZwaVWpFlOjSO/4Nx++Ef4pY5aPS
zNpXcXCZgUdA67qmOILvrG7bnDR60dcBZVBl7CjnpTlccg7MD4CBsFJx+hGRPD2yIV94
-----END RSA PRIVATE KEY-----
06. Salve a parte da saída que começa com —–BEGIN RSA PRIVATE
KEY—– em um arquivo local. Essa será a chave privada a ser usada
para ativar instâncias e acessá-las com SSH. Certifique-se de manter o arquivo
privado e seguro. Se você ativar uma instância com essa chave e perder a chave
posteriormente, não será mais necessário se conectar à sua instância usando o
shell. Nomeie o arquivo-chave pk-devworks e modifique
as permissões no arquivo para torná-lo mais seguro.
Listagem 4. Alterar permissões da chave privada
$ chmod 600 pk-devworks
Agora, o ambiente de desenvolvimento está configurado.
Ativar a primeira instância
Será iniciada a primeira instância de uma das imagens públicas fornecidas por
RightScale, com base em CentOS. O ID de AMI desta imagem é ami-d8a347b1.
Listagem 5. Iniciar uma instância
$ ec2-run-instances –k devworks -n 1 ami-d8a347b1
RESERVATION r-2691404f 710193521658 default
INSTANCE i-7f923516 ami-d8a347b1 pending
devworks 0 m1.small 2008-09-07T18:05:34+0000
us-east-1c aki-9b00e5f2
Uma instância recém-ativada está sempre no estado pendente. Essa instância não pode ainda ser endereçada de nenhuma forma, visto que ainda
está inicializando. Nesse estado, é possível ver os seguintes detalhes sobre essa
instância:
- Hora de ativação: a hora em que esta instância foi ativada, exibida em
UTC. - Tipo de instância: não foi especificado o tipo de instância na ativação,
portanto, o EC2 automaticamente escolheu a instância default m1.small para
nós. - Zona de disponibilidade: não foi especificada uma zona de
disponibilidade na ativação, portanto, o EC2 selecionou uma com base na
funcionalidade e no funcionamento dos sistemas atuais. - Kernel: o kernel Linux usado por essa instância é também exibido. É
possível especificar isso na ativação, ou a AMI pode ser pré-configurada com uma
como padrão. - Grupo de segurança: a instância foi colocada no grupo de segurança default. É possível criar seus próprios grupos de
segurança, conceder permissões de acesso para eles e colocar a instância nesses
grupos. É necessário especificar o grupo de segurança na ativação. Não é
possível alterar o nome do grupo quando a instância é ativada, mas é permitido
alterar as concessões do grupo.
Pode-se agora listar as instâncias em execução e verificar o estado atual.
Listagem 6. Listar instâncias
$ ec2-describe-instances
RESERVATION r-2691404f 710193521658 default
INSTANCE i-7f923516 ami-d8a347b1 ec2-67-202-28-68.compute-1.amazonaws.com
domU-12-31-38-00-34-C8.compute-1.internal running devworks 0
m1.small 2008-09-07T18:05:34+0000 us-east-1c aki-9b00e5f
Observe que a instância está em execução e os detalhes adicionais sobre essa
instância, como:
- Nome DNS público: o nome DNS que pode ser usado para conexão com essa
instância pela Internet. - Nome DNS privado: o nome DNS u sado para resolver essa instância na rede
local do EC2 no ambiente de datacenter do Amazon.
Conectar-se à primeira instância usando SSH
É possível agora definir o SSH na instância usando nossa chave privada e o nome DNS
público para a instância.
Listagem 7. SSH para a instância
$ ssh -i pk-devworks root@ec2-67-202-28-68.compute-1.amazonaws.com
The authenticity of host 'ec2-67-202-28-68.compute-1.amazonaws.com (10.252.59.54)'
can't be established.
RSA key fingerprint is ae:e5:00:54:75:65:1c:c5:44:53:72:b9:e0:b5:26:a9.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'ec2-67-202-28-68.compute-1.amazonaws.com,10.252.59.54'
(RSA) to the
list of known hosts.
[root@domU-12-31-38-00-34-C8:~]
Pode ser exibida uma mensagem de erro após se efetuar o login acima, mas é possível
ignorar isso com segurança. A AMI executa alguns scripts RightScale customizados
após a inicialização, que estão faltando.
Personalizar e criar novamente o pacote configurável da instância
O AMI RightScale é muito abrangente e contém tudo o que você precisa para começar a
usá-lo como sua imagem base. Ele já possui as ferramentas de linha de comando do EC2
em directory/home/ec2.
01. Adicione os certificados de segurança. Esses são os mesmos arquivos usados na Listagem 1.
Listagem 8. Copiar seus certificados para a instância
$ scp -i pk-devworks path_to_your_private_key_cert
root@ec2-67-202-28-68.compute-1.amazonaws.com:/home/ec2/
$ scp -i pk-devworks path_to_your_x509_cert
root@ec2-67-202-28-68.compute-1.amazonaws.com:/home/ec2/
02. Configure as variáveis de ambiente para que possa usar isso como sua própria
imagem EC2 particular. Edite o arquivo /etc/profile.d/env.sh e configure cada
uma das variáveis. O número da conta e as chaves de acesso estão disponíveis em
Web services account information, enquanto a chave de certificação e a
chave privada são os arquivos copiados para a instância na etapa anterior.
Listagem 9. Customizar o ambiente de instância
$ vim /etc/profile.d/env.sh
export EC2_HOME=/home/ec2
export EC2_CERT=
export EC2_PRIVATE_KEY=
export AWS_ACCOUNT_NUMBER=
export AWS_ACCESS_KEY_ID=
export AWS_SECRET_ACCESS_KEY=
export PATH=$PATH:/home/ec2/bin/
# Turn off the rightscripts so you don’t get the error on login.
$ chkconfig --level 4 rightscale off
# Change the login message
$ echo “Welcome to my devworks test EC2 image� > /etc/motd
03. Esta imagem já tem Ruby instalado, mas é necessário instalar as bibliotecas de
Ruby que serão usadas mais adiante neste artigo para interação com o EC2.
Primeiro, você atualizará os gems instalados e instalará os gems right_aws e todas as dependências necessárias.
Listagem 10. Instalar gems Ruby
$ gem update
$ gem install right_aws
04. Você está pronto para criar o pacote configurável novamente desta instância,
carregá-lo para S3 e registrá-lo com o EC2. Primeiro, crie novamente o pacote
configurável da instância abaixo do nome devworks-ec2 e ignore as pastas /mnt e /tmp. É preciso também especificar a chave privada do
EC2, o certificado de segurança do EC2 e o número da conta do Amazon Web
Services.
Listagem 11. Criar novamente o pacote configurável da instância
$ ec2-bundle-vol -d /mnt -c /home/ec2/your_ec2_x509_cert
-k /home/ec2/your_ec2_private_key -u your_aws_account_number
-e /mnt,/tmp -s 10240 -r i386 -p devworks-ec2
05. O processo de criar novamente o pacote configurável criará um agrupamento de
arquivos no diretório /mnt, assim que tiver sido concluído. Você carregará esses
arquivos, que compreendem a AMI recém-criada, para S3. A imagem será colocada no
depósito especificado. Substitua o parâmetro –b no
comando abaixo pelo nome do depósito onde deseja armazenar seus arquivos de
imagem no S3.
Listagem 12. Carregar imagem para S3
$ ec2-upload-bundle -b your_s3_bucket -m /mnt/devworks-ec2.manifest.xml
-a your_aws_access_key -s your_aws_secret_key
06. Sua AMI agora está armazenada com segurança no S3. Tudo o que resta fazer é
registrá-la com o EC2 para que possa obter um ID para a AMI, que pode ser usado
para ativar essa imagem posteriormente.
Listagem 13. Registrar a imagem com EC2
$ ec2-register -K /home/ec2/your_ec2_private_key
-C /home/ec2/your_ec2_x509_cert your_s3_bucket/devworks-ec2.manifest.xml
IMAGE ami-58c42031
07. Saia da sessão SSH e encerre a instância em execução.
Listagem 14. Encerrar nossa instância
$ ec2-terminate-instances i-7f923516
INSTANCE i-7f923516 running shutting-down
Você ativará uma nova instância a partir da AMI recém-criada na próxima seção e a
usará no restante deste artigo para explorar E C2 usando a biblioteca right_aws.
Explorando EC2 com Ruby
RightScale fornece uma biblioteca Ruby, right_aws, que fornece acesso ao serviço EC2 do Amazon a partir de Ruby.
Essa biblioteca testada na prática é usada pelos seus próprios produtos e abrange
todos os aspectos do EC2, incluindo o EBS recém-apresentado.
A biblioteca é
empacotada como um rubygem, junto com a biblioteca HTTP RightScale:HttpConnection, que tem novas tentativas robustas e manipulação
de erros. Este artigo aborda apenas algumas d as funções de EC2 fornecidas por esta
biblioteca.
É altamente recomendado revisar a documentação fornecida com a
biblioteca para se ter uma visão abrangente da API. Revise as várias opções de
configuração da biblioteca right_aws e da biblioteca de
suporte right_http_connection.
Você usará a classe Rightscale::Ec2, que fornece a interface principal para a nossa interação com o EC2. O meio de uso dessa biblioteca Ruby será o console irb.
Será preciso enviar mensagens ao objeto Rightscale::Ec2 e examinar as respostas retornadas pelo EC2 às mensagens. Isso o ajudará a se familiarizar com a API enquanto explora os conceitos do EC2.
01. Inicie uma instância pela nova AMI. Quando a instância estiver em um estado de
execução, use SSH para a instância. Em seguida, você começará a usar o console
irb dentro da instância.
Listagem 15. Iniciar nova instância e SSH nela
$ ec2-run-instances -k devworks -n 1 ami-58c42031
RESERVATION r-5795443e 710193521658 default
INSTANCE i-1a9e3973 ami-58c42031 pending devworks 0
m1.small 2008-09-07T21:06:37+0000 us-east-1c aki-9b00e5f2
$ ec2-describe-instances
RESERVATION r-949544fd 710193521658 default
INSTANCE i-5a9d3a33 ami-58c42031
ec2-75-101-208-95.compute-1.amazonaws.com
domU-12-31-38-00-78-04.compute-1.internal
running devworks 0 m1.small
2008-09-07T21:14:27+0000 us-east-1c aki-9b00e5f2
$ ssh -i pk-devworks root@ec2-75-101-208-95.compute-1.amazonaws.com
02. Inicie o shell Ruby e crie um objeto Rightscale::Ec2.
Listagem 16. Shell Ruby e o novo objeto Rightscale::Ec2
$ irb
irb(main):001:0> require 'rubygems'
=> true
irb(main):002:0> require 'right_aws'
=> true
irb(main):003:0> @ec2 = Rightscale::Ec2.new(
ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'])
Use essa variável recém-criada @ec2 deste ponto em diante para explorar o EC2.
O exemplo está usando a configuração padrão para esta biblioteca. Consulte a
documentação da lista de opções de configuração disponíveis.
01. A recuperação de uma lista de suas instâncias retorna um array de hashs, com
cada hash fornecendo os detalhes relevantes de cada instância. Esse é um padrão
comum do formato de resposta seguido por quase todas as chamadas de API dessa
biblioteca. A Listagem 17 mostra um exemplo.
Listagem 17. Descrever suas instâncias
irb(main):004:0> @ec2.describe_instances()
=> [{:aws_launch_time=>"2008-09-07T21:14:27.000Z", :aws_kernel_id=>"aki-9b00e5f2",
:ssh_key_name=>"devworks", :aws_reservation_id=>"r-949544fd",
:aws_availability_zone=>"us-east-1c",
:aws_state=>"running", :aws_instance_id=>"i-5a9d3a33", :aws_groups=>["default"],
:aws_image_id=>"ami-58c42031",
:aws_product_codes=>[], :dns_name=>"ec2-75-101-208-95.compute-1.amazonaws.com",
:aws_state_code=>"16",
:private_dns_name=>"domU-12-31-38-00-78-04.compute-1.internal",
:aws_instance_type=>"m1.small",
:aws_reason=>"", :ami_launch_index=>"0"}]
02. Recupere uma lista de suas imagens.
Listagem 18. Descrever suas imagens
irb(main):005:0> @ec2.describe_images_by_owner([ENV['AWS_ACCOUNT_NUMBER']])
=> [{:aws_location=>"ylastic_images/devworks-ec2.manifest.xml",
:aws_kernel_id=>"aki-9b00e5f2", :aws_state=>"available", :aws_is_public=>false,
:aws_architecture=>"i386", :aws_id=>"ami-58c42031", :aws_image_type=>"machine"}]
03. Crie um grupo de segurança que possa ser usado para organizar as instâncias e
restringir ou conceder acesso a ele.
Listagem 19. Criar um novo grupo de segurança e listar grupos
irb(main):006:0> @ec2.create_security_group("devworks",
"Devworks Article Security Group")
=> true
irb(main):008:0> @ec2.describe_security_groups()
=> [{:aws_group_name=>"devworks", :aws_description=>"Devworks Article Security
Group",
:aws_perms=>[]}]
04. Crie um novo par de chaves de segurança e liste todos os pares de chave de sua
conta.
Listagem 20. Criar um novo par de chaves de segurança e listar pares de chaves
irb(main):018:0> @ec2.create_key_pair('mykeypair')
=> {:aws_key_name=>"mykeypair",
:aws_fingerprint=>"c6:62:22:9e:99:05:6a:17:13:06:e0:86:f9:55:2a:78:ff:99:6b:fa",
:aws_material=>"-----BEGIN RSA PRIVATE KEY-----
\nMIIEpAIBAAKCAQEAyRdAvihBXDu30o2uvQ1h8xdIRLHs0RjQWK4Yw5Y5DkaS41EEjnDwjO6sEY5l\n
IXSuzVj1nkZ1VMPuVR3hIXHCMJLaAO77TaXZVC9yymIUAyTcQ1+hoVLlrCuVI3dEY21WQNTEbtkI\nlI
xMW+UhkiaKrGHmt2yYLjr754KGt7pNCpRwxPXB7brlpQ3qpapkr7XrKZppvWoG8MCmPIFx8P0K\no8Cd
mnF9lEdns6uaJZmfs4Ls9HZHpsmn0r42GbOAkJEkj7nE5zc3rXYpmCBZhjyHus0iXjS/n9oL\nHWhV0a
wagjvmsQgJPYqEsBeO5pDb2IOZq5okQie1YJTd1m8k8k7m9wIDAQABAoIBAQCK0lWssOem\nP8fAQHVg
J+v1wJ3wZpBhLWsvvUh1RbCvzUK8UQL/PrKh6Ga7W/0u4nmGY6J0mJmJYhWXhyATUZBI\nrih3uoOccC
Eff/4T/y9nmDvC+zL+xtatTA0SRdTdeu6vpPLSv1uwCUbxrbXGSnszVAbNm9dXGvsq\nMK7GCYQEB4p4
FtJolDqGZdWAj1u5/AGjbCI+PbkbCAro55Sqnl95WAlogdQFmgxljWl9TEIsbrHf\nYZHtKHlm1lvyeB
QdVmwLT9S7ufI1J/GAevRxrG2iEkx/IJWYGnQE0P2bXa6Ry90UyvWRPS6Zi/MD\nfWoFAxnB6Ryssr+S
IAfpG6SGuM55AoGBAOr7yPcvg/66f/Xd3CbpmI8lIfsXBb9xki3pIEfYAWD/\n2ToxpRYPTgrwwB1ufo
NPr7U1QfzJvAvlTXWkfp4oUnssi5sXw1okZmm01hT0j0FNvsgMG6zD8Z/9\nmgrVrH+tBxVoYqrPM/WB
dnYhQXEGQq+UF2uPqoKDbsl3DkftXTBrAoGBANsTdLfHmRidkLCRKfSj\nUrbJOSsU6RWGFuoqgD+DZL
ngKBTaBTd6TVONSR2JvpVJo5hyiAXQ/jQ1XtsPAuJR6fiiRvDfgF7j\n1lp1tsFpNYx2R4+eqoLrHgIC
Ak1Ke8tWyoD3NgQ4FO9TDfW+QHn0dpLeWdNMUd2a1GVKp4hIoJal\nAoGBAITqMryO5eyZ9XNPMQ3Zp+
+gI15xoVCunu7VJOs+ZVlGnsrp9eVKdux9TU3YiDsiQdMP8ulX\n+sQHyg63It+3EyCVC8qIYHmGiV9V
aJql0rovjbB+GNFabDwBKLbkMhRt/MnBJ75SQaOmvSkImomh\n7up9q9mtg9cbHPlcHHnW65VNAoGAKi
+Y7jrVVFQjJJ0PgzhgGSqug4lHSQnFJ9p/T7uxjcmIblt9\nXa2Dbm9qgPGhbYX8psKHRvdzvAH6/hvp
5kL31xUIrCGdyqf9AvZf9uaXlTDBnvpiw0sbQC+62b9a\nD1HrNOJl2HIkNeG8cnHsYI+etbFzgqjTqu
TBua+iiy/RHLECgYALIDqaAcd7o4V+ws+WG1G9vTlc\nJ6/sBpu3JyKMSdJYlbgIbvHgrfbKhEYuNh/H
XNdrI6oeW9eAruqHlH+OlUx0tCg4VIeQsz/b7kPS\nY14OMAswuHHyqlZIqK4Xy/R6SQmsc/CUXWPk5I
UesJk5f1V1NXIqqwv6+nlEucdjgYUd5w==\n-----END RSA PRIVATE KEY-----"}
irb(main):020:0> @ec2.describe_key_pairs()
=> [{:aws_key_name=>"mykeypair",
:aws_fingerprint=>"c6:62:22:9e:99:05:6a:17:13:06:e0:86:f9:55:2a:78:ff:99:6b:fa"}]
05. Crie um novo volume EBS. Especifique a zona de disponibilidade desse volume como us-east-1c. Esse volume, uma vez criado e
disponível, poderá ser vinculado somente a uma instância em execução na mesma
zona de disponibilidade. O volume estará inicialmente no estado criando.
Quando o processo estiver concluído, o volume estará disponível.
Listagem 21. Criar um novo volume EBS e listar volumes
irb(main):024:0> @ec2.create_volume('', 1, 'us-east-1c')
=> {:aws_status=>"creating", :aws_created_at=>Mon Sep 08 00:29:35 UTC 2008,
:zone=>"us-east-1c", :aws_size=>1, :snapshot_id=>nil, :aws_id=>"vol-2f34d146"}
irb(main):026:0> @ec2.describe_volumes()
=> {:aws_status=>"available", :aws_created_at=>Mon Sep 08 00:29:35 UTC 2008,
:zone=>"us-east-1c", :aws_size=>1, :snapshot_id=>nil, :aws_id=>"vol-2f34d146"}
06. Vincule esse volume à instância atual como dispositivo de bloco /dev/sdj e formate-o com o sistema de arquivos ext3 para que possa de fato ser usado.
Listagem 22. Vincular o novo volume EBS e criar sistema de arquivos
irb(main):031:0> @ec2.attach_volume('vol-2f34d146', 'i-5a9d3a33', '/dev/sdj')
=> {:aws_instance_id=>"i-5a9d3a33", :aws_device=>"/dev/sdj",
:aws_attachment_status=>"attaching", :aws_id=>"vol-2f34d146",
:aws_attached_at=>Mon Sep 08 00:34:03 UTC 2008}
$ mkfs.ext3 /dev/sdj
mke2fs 1.39 (29-May-2006)
/dev/sdj is entire device, not just one partition!
Proceed anyway? (y,n) y
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
131072 inodes, 262144 blocks
13107 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=268435456
8 block groups
32768 blocks per group, 32768 fragments per group
16384 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376
Writing inode tables: done
Creating journal (8192 blocks): done
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 39 mounts or
180 days, whichever comes first. Use tune2fs -c or -i to override.
07. Monte o dispositivo do bloco recém-formatado em uma pasta de sistema de
arquivos.
Listagem 23. Montar o volume em um diretório local e usá-lo
$ mount /dev/sdj /mnt/my-vol
$ echo “Hello Devworks� > /mnt/my-vol/test.txt
# cat /mnt/my-vol/test.txt
Hello Devworks
Agora, é possível usar esse volume EBS exatamente como qualquer outro dispositivo de
bloco presente no sistema. É possível ler a partir do volume e gravar nele.
Quando
terminar de usar o volume, desconecte-o da instância em execução e reconecte a outra
instância ou à mesma instância, sempre que quiser. Isso é um armazenamento
persistente que realmente eleva o EC2 a um novo nível de utilidade.
Há muitas formas
de aproveitar esse recurso, como usá-lo para armazenar seus dados de banco de dados
valiosos nos logs de servidor da Web, que precisam existir além de uma instância.
É possível criar uma captura instantânea de um volume EBS que manterá o conteúdo do
volume em um ponto no tempo. As capturas instantâneas são armazenadas
automaticamente no S3 e criadas pelo EC2 de maneira acumulativa.
A primeira captura
instantânea de um volume será uma cópia completa, mas armazenará apenas os conjuntos
de mudanças. Existe atualmente um limite de 500 capturas instantâneas permitidas por
conta de Amazon Web Services. Se você precisar armazenar mais de 500 capturas
instantâneas, poderá solicitar um aumento no limite de contas.
Listagem 24. Criando uma captura instantânea de um volume EBS
irb(main):007:0> @ec2.create_snapshot('vol-2f34d146')
=> {:aws_status=>"pending", :aws_volume_id=>"vol-2f34d146",
:aws_started_at=>Mon Sep 08 00:49:15 UTC 2008, :aws_progress=>"",
:aws_id=>"snap-13db3c7a"}
A captura instantânea é criada pelo EC2 em segundo plano. É possível listar todos os
instantâneos periodicamente para garantir que a criação tenha sido concluída com
êxito.
Listagem 25. Listando as capturas de tela de EBS
irb(main):008:0> @ec2.describe_snapshots()
=> [{:aws_status=>"completed", :aws_volume_id=>"vol-2f34d146",
:aws_started_at=>Mon Sep 08 00:49:15 UTC 2008, :aws_progress=>"100%",
:aws_id=>"snap-13db3c7a"}]
Por fim, é possível separar um volume de sua instância. É possível vincular novamente
o volume à mesma instância ou a uma outra instância em um ponto posterior.
Listagem 26. Separando um volume EBS
irb(main):006:0> @ec2.detach_volume('vol-2f34d146')
=> {:aws_instance_id=>"i-5a9d3a33", :aws_device=>"/dev/sdj",
:aws_attachment_status=>"detaching", :aws_id=>"vol-2f34d146",
:aws_attached_at=>Mon Sep 08 00:34:03 UTC 2008}
Conclusão
Este artigo apresentou o serviço EC2 do Amazon e abordou os conceitos básicos. Você viu algumas das funções fornecidas por right_aws, uma biblioteca Ruby de software livre para interação com o EC2.
Abordamos bastante coisa, mas EC2 é um tópico muito grande e complexo. É altamente recomendado ler o Guia do desenvolvedor do EC2 do Amazon para obter mais informações.
Na Parte 4
desta série Computação em nuvem com Amazon Web
Services, vamos examinar o Amazon Simple Queue Service (SQS) para sistema de
mensagens confiável na nuvem. Até a próxima!
Recursos
Aprender
- Saiba mais sobre Amazon Web Services específicos:
- Amazon Simple Storage Service (S3)
- Amazon Elastic Compute Cloud (EC2)
- Amazon Simple Queue Service (SQS)
- Amazon SimpleDB (SDB)
- O Service Health Dashboard é
atualizado pela equipe do Amazon e fornece o status atual de cada
serviço. - Os acontecimentos mais recentes no mundo do Amazon Web Services estão no blog.
- Inscreva-se para uma conta Amazon Web Services.
- OpenSolaris está disponível em Amazon public Grid.
- O Amazon Web Services Developer
Connection é o gateway para todos os recursos do desenvolvedor. - A equipe do Amazon Web Services fornece
documentação técnica, guias do usuário e artigos de interesse para desenvolvedores
em EC2 Technical Resources. - O Developer Guide for EC2 tem informações sobre os vários componentes do
serviço EC2, além de uso e configuração avançados. - Uma lista de todas as Amazon Machine Images está disponível no site de conexão do desenvolvedor
da AWS. - O Amazon fornece várias ferramentas de linha de comando que facilitam a criação e o gerenciamento
de imagens. - Gerencie as chaves e o certificado, gere-os
novamente, veja relatórios de uso e atividade da conta e modifique as informações do
seu perfil na página de dados da conta de serviços da Web . - Use a calculadora mensal
simples para calcular seus custos de uso mensais para EC2 e os outros Amazon
Web Services. - Obtenha o feed RSS desta série.
- Na área Architecture no
developerWorks, obtenha os recursos necessários para melhorar suas
qualificações na área architecture. - Navegue até a livraria
de tecnologia para obter livros sobre estes e outros tópicos técnicos.
***
artigo publicado originalmente no developerWorks Brasil, por Prabhakar Chaganti
Prabhakar Chaganti é o diretor de tecnologia (CTO) da Ylastic, uma empresa que está criando
uma interface unificada exclusiva para arquitetar, gerenciar e monitorar todo o ambiente de
computação da nuvem AWS de um usuário: EC2, S3, SQS e SimpleDB. Ele é autor de dois livros
recentes, Xen Virtualization e GWT Java AJAX Programming É também vencedor do
prêmio de escolha da comunidade pelo dispositivo virtual mais inovador no VMware Global Virtual
Appliance Challenge.
De 0 a 10, o quanto você recomendaria este artigo para um amigo?