- Clique em Serviços para exibir a caixa de pesquisa.
- Digite o nome do serviço que você deseja – neste caso, EC2.
- Clique no nome do seu serviço no menu para levá-lo ao painel de serviços.
Selecione ‘Iniciar instância’
Quando estivermos no Painel do EC2, clique no botão ‘Iniciar instância’ no meio da tela. Isso iniciará o AWS EC2 Launch Wizard, que guiará o processo de inicialização de uma instância do EC2.
Se você quiser passar pela parte 2, na qual iniciaremos um servidor EC2 programaticamente com Python, é uma excelente chance de anotar seu ID de VPC padrão!
Visão geral do Assistente do EC2
Depois de selecionar ‘Iniciar instância’, você será levado a um assistente. O menu do assistente possui 7 etapas, e você pode alternar entre elas conforme desejar para configurar sua instância da maneira que desejar.
Assistente EC2 – selecione seu tipo de AMI
Aqui é onde a mágica acontece!
É aqui que você escolherá o seu tipo de AMI, que é basicamente o sistema operacional que você deseja. Existem inúmeras AMIs pré-configuradas para muitos casos de uso comuns, incluindo aplicativos ML, servidores da Web e bancos de dados. Confira a AWS Marketplace para ver todas as AMIs legais por aí!
Eu gosto da imagem do Amazon Linux 2, mas você pode procurar qualquer tipo de imagem, incluindo Ubuntu, Centos ou qualquer número de Bitnami imagens.
Nota lateral rápida aqui. Eu amo as imagens Bitnami. Eles são impressionantes e, se você estiver pensando em implantar qualquer tipo de aplicativo da Web, como Ghost, WordPress, Nginx ou aplicativos ainda mais complexos, como Redash ou Airflow, eu realmente os recomendo.
Assistente EC2 – Escolha seu tipo de instância
Vou com a gratuita porque pretendo acabar com isso, mas se você estiver realmente usando esta instância do EC2 para algo importante, precisará adicionar mais energia. Se você precisar de algo que envolva a Internet, como a transferência de dados, preste atenção nos recursos da Internet e escolha algo na faixa moderada.
Role para baixo e escolha ‘Iniciar’ para iniciar com as configurações padrão ou ‘Configurar sua instância’ para adicionar configurações adicionais, como alterar o tamanho do sistema de arquivos raiz, escolher uma VPC ou adicionar dados do usuário.
Assistente EC2 – Adicionar tags
Quando você está começando, isso não importa muito, mas à medida que avança na AWS, você deve garantir que todas as suas instâncias tenham, no mínimo, Name Tag. Isso permitirá que você pesquise mais facilmente suas instâncias e faça coisas legais, como criar grupos de recursos para agrupar seus serviços da AWS.
No menu do assistente, selecione ‘Adicionar tags’. Não se preocupe, você pode alternar entre as etapas do assistente quantas vezes quiser.
Assistente EC2 – Configurar o grupo de segurança
Antes de terminar, configuraremos o grupo de segurança, que é o que define as regras de acesso. A AWS criará um grupo de segurança para você ou você já pode escolher um. O padrão é abrir a porta 22 para SSH, mas se você usar isso para qualquer aplicativo da Web ou de banco de dados, também precisará abrir essas portas.
Assistente EC2 – LANÇAMENTO
Agora que dissemos à AWS o que queremos, vamos lançar nossa instância! Clique em Revisar e Iniciar. Você verá uma janela pop-up perguntando qual chave SSH você deseja. Você também pode criar um novo par de chaves SSH aqui.
Assistente EC2 – Página de confirmação
Depois de iniciado, você será levado a uma página de confirmação com seu ID da instância do EC2.
Painel EC2 – Obtenha seu endereço IP
Aqui vamos nós! Agora, tudo o que resta é esperar que nossa instância esteja pronta e SSH novamente.
Está bem! Agora só precisamos fazer o SSH para nossa instância. Os detalhes para isso serão ligeiramente diferentes, dependendo do tipo de instância que você escolheu.
Isso pressupõe que você baixou seu par de chaves chamado my-remote-server.pem e mudou para ~/.ssh
chmod 400 ~/.ssh/my-remote-server.pem
# Amazon linux 2 ami
ssh -i ~/.ssh/my-remote-server.pem ec2-user@PUBLIC_DNS
# Ubuntu or Bitnami
ssh -i ~/.ssh/my-remote-server.pem ubuntu@PUBLIC_DNSÉ isso aí! Agora você tem um servidor remoto na nuvem!
Gire uma instância do EC2 com a biblioteca Boto3 Python
Isenção de responsabilidade aqui. Isso está muito além do que eu normalmente faria com a biblioteca boto3. Para qualquer coisa além de iniciar uma instância do EC2, eu recomendaria o uso do console ou uma infraestrutura como ferramenta de código, como Cloudformation ou Terraform. Mas quando você está começando, é realmente importante entender as bases.
Eu também tenho uma necessidade obsessiva de escrever relatórios para absolutamente tudo. Sinta-se livre para remover se você não é tão paranóico. 😉
import boto3
import time
import json
from pprint import pprint
from select import select
import logging
from logging import Logger
from paramiko import SSHClient
import paramiko
from typing import Any
import os
logger = logging.getLogger('launch_ec2')
logger.setLevel(logging.DEBUG)
PROJECT = "my-remote-server"
KEY_PAIR = "my-remote-server"
SECURITY_GROUP="sg-some-number"
# Amazon Linux 2 AMI
AMI_ID="ami-062f7200baf2fa504"
INSTANCE_TYPE="t3a.medium"
report_data = {
'name': PROJECT,
'computer_name': KEY_PAIR,
}
def initialize_dir():
"""
Initialize a directory to write out our keypair and reports
"""
if not os.path.exists(KEY_PAIR):
os.mkdir(KEY_PAIR)
def create_key_pair():
ec2_client = boto3.client('ec2')
key_pair_response = ec2_client.create_key_pair(KeyName=KEY_PAIR)
report_data['ssh_key'] = {}
report_data['ssh_key']['id'] = key_pair_response['KeyPairId']
report_data['ssh_key']['name'] = key_pair_response['KeyName']
report_data['ssh_key']['key'] = key_pair_response['KeyMaterial']
report_data['ssh_key']['key_file'] = os.path.abspath(os.path.join(KEY_PAIR, 'keypair.pem'))
logger.info('Successfully created ssh key')
def write_key_file():
"""
Write out the .pem ssh key file
:return:
"""
f = open(os.path.join(KEY_PAIR, 'keypair.pem'), 'w+')
f.write(report_data['ssh_key']['key'])
f.close()
os.chmod(os.path.join(KEY_PAIR, 'keypair.pem'), 0o400)
logger.info(
'Wrote out ssh key file to {keypair}'.format(
keypair=
os.path.abspath(os.path.join(KEY_PAIR, 'keypair.pem'))
)
)
def create_instance():
ec2 = boto3.resource('ec2')
instance = ec2.create_instances(
SecurityGroupIds=[SECURITY_GROUP],
ImageId=AMI_ID,
MinCount=1,
MaxCount=1,
InstanceType=INSTANCE_TYPE,
KeyName=KEY_PAIR,
TagSpecifications=[
{
'ResourceType': 'instance',
'Tags': [
{
'Key': 'Name',
'Value': PROJECT
},
]
},
],
)
report_data['ec2'] = {}
report_data['ec2']['id'] = instance[0].id
report_data['ec2']['PublicIP'] = None
def get_public_ip():
print('Waiting for instance to initialize with public IP address...')
print('This may take some time...')
time.sleep(10)
ec2 = boto3.resource('ec2')
running_instances = ec2.instances.filter(Filters=[
{
'Name': 'instance-state-name',
'Values': ['running']
},
{
'Name': 'instance-id',
'Values': [report_data['ec2']['id']]
}
])
for instance in running_instances:
# Add instance info to a dictionary
report_data['ec2'] = {
'instance_id': report_data['ec2']['id'],
'Type': instance.instance_type,
'State': instance.state['Name'],
'PrivateIP': instance.private_ip_address,
'PublicIP': instance.public_ip_address,
'LaunchTime': str(instance.launch_time)
}
def write_report():
"""
Write out a JSON file with all of the IDs and things we need
"""
logger.info('Writing report to {}'.format(
os.path.abspath(os.path.join(KEY_PAIR, 'report.json'))
))
f = open(os.path.abspath(os.path.join(KEY_PAIR, 'report.json'))
, 'w+')
json.dump(report_data, f, ensure_ascii=False, indent=4)
f.close()
def print_helper_commands():
"""
Print some helper commands for ssh and rsync to the screen
"""
rsync_command = "rsync -av --progress -e 'ssh -i {key_file}' HOST_DIR ec2-user@{public_id}:/home/ec2-user/efs".format(
key_file=report_data['ssh_key']['key_file'],
public_id=report_data['ec2']['PublicIP']
)
ssh_command = "ssh -i {key_file} ec2-user@{public_ip}".format(
key_file=report_data['ssh_key']['key_file'],
public_ip=report_data['ec2']['PublicIP']
)
report_data['ssh_command'] = ssh_command
report_data['rsync_command'] = rsync_command
print('Some helpful commands!')
print('###################################')
print('# SSH to the instance with: ')
print(ssh_command)
print('###################################')
print('###################################')
print('# Rsync data to the instance with: ')
print(rsync_command)
print('###################################')
def print_end_message():
print('##################################')
print('Finished!')
print('See {dir}/report.json for details'.format(dir=KEY_PAIR))
initialize_dir()
create_key_pair()
write_key_file()
create_instance()
while report_data['ec2']['PublicIP'] is None:
get_public_ip()
print_helper_commands()
write_report()
print_end_message()
Embrulhar
É tudo o que você precisa saber para começar a ativar servidores remotos na nuvem! Quais tipos de projetos você deseja implantar na nuvem?