AWS este atât de cool, deoarece este alcătuit din blocuri de construcție discrete pe care le puteți folosi pentru a construi o infrastructură destul de complexă. Acest lucru este minunat odată ce te descurci cu lucrurile. Dar când abia începeți, trebuie să știți lucruri precum „cum obțin adresa IP a serverului meu” și „așteptați cheia SSH”.

Să trecem în revistă câteva dintre conceptele cheie și apoi să ne rotim propriul server pe cloud!

Ce trebuie să știți pentru a administra servere la distanță pe AWS

Există multe motive pentru care ați putea dori să începeți cu AWS. Poate că compania dvs. mută infrastructura în cloud. Poate doriți să începeți freelancing-ul și nu doriți să investiți în costuri de server în avans. Sau poate doriți doar să învățați un nou set de abilități.

Pentru a crea un server la distanță pe AWS, trebuie să cunoașteți câțiva termeni și concepte AWS fundamentale. Voi trece în revistă câțiva termeni care se aplică direct în cazul în care rulează un server la distanță, dar aceleași concepte sunt folosite pentru servicii de infrastructură mai complexe precum ElasticBeanstalk, Docker Swarm și Kubernetes.

Cloud de calcul elastic (EC2)

AWS EC2 instanțele sunt locul în care calculezi viața puterii. Acestea sunt serverele dvs. la distanță. Știind cum să gestionați instanțele EC2 este extrem de important, deoarece apar aproape peste tot.

Grupuri de securitate

Grupuri de securitate sunt cele care permit accesul la diferitele dvs. servicii AWS, în acest caz o instanță EC2. Acestea definesc ce porturi sunt deschise pentru traficul intern și exterior.

Perechi cheie

Perechi de chei sunt cheile dvs. SSH. Asigurați-vă că țineți evidența acestora și păstrați-le undeva în siguranță! De asemenea, dacă utilizați AWS mult, veți începe o colecție de perechi de chei, deci asigurați-vă că le dați nume descriptive și nu doar ssh. 😉

Cloud privat virtual (VPC)

A VPC este o resursă izolată în care trăiește infrastructura dvs. de calcul. Să continui cu totul este filosofia Legos, VPC este cutia Lego, în timp ce EC2, Grupurile de securitate și KeyPairs sunt Legos-urile reale.

VPC-urile se ocupă de toate rețelele dvs. Când vă înscrieți pentru un cont AWS, veți obține un VPC implicit și asta vom folosi astăzi.

Cum se lansează o instanță EC2

Există atât de multe modalități de a lansa o instanță EC2. Pe care îl doriți va depinde de nevoile dvs. Astăzi vom analiza folosind consola web AWS și folosind python boto3 bibliotecă.

Deoparte, deoarece AWS are atât de multe servicii, trebuie să accesați fiecare serviciu individual pentru a-l gestiona. Dacă v-ați pierdut vreodată, trebuie doar să căutați serviciul dvs. din meniul „Servicii”.

Lansați o instanță EC2 utilizând Expertul

Mai întâi va trebui să vă conectați la Consola AWS.

Cum sa spinati un server la distanta pe AWS
Afișați pagina de servicii EC2 căutând-o în „Servicii”

  1. Faceți clic pe Servicii pentru a afișa caseta de căutare.
  2. Tastați numele serviciului dorit – în acest caz, EC2.
  3. Faceți clic pe numele serviciului dvs. din meniu pentru a vă duce la tabloul de bord al serviciilor.

Selectați „Lansați instanța”

Odată ce am ajuns la tabloul de bord EC2, veți dori să faceți clic pe butonul „Lansați instanța” din mijlocul ecranului. Aceasta va porni AWS EC2 Launch Wizard, care ne va ghida prin procesul de pornire a unei instanțe EC2.

Dacă doriți să parcurgeți partea 2, unde vom porni un server EC2 programat cu Python, aceasta este o șansă excelentă de a vă nota id-ul VPC implicit!

1611551707 760 Cum sa spinati un server la distanta pe AWS

Prezentare generală a asistentului EC2

După ce selectați „Lansați instanța”, veți fi adus la un expert. Meniul vrăjitorului are 7 pași și puteți comuta între ei după cum doriți pentru a configura instanța dvs. exact așa cum doriți.

1611551708 240 Cum sa spinati un server la distanta pe AWS

Expertul EC2 – Selectați tipul dvs. AMI

Aici se întâmplă magia!

1611551708 844 Cum sa spinati un server la distanta pe AWS

Aici vă veți alege tipul AMI, care este cel mai mult sistemul de operare pe care îl doriți. Există orice număr de AMI preconfigurate pentru o mulțime de cazuri de utilizare obișnuite, inclusiv aplicații ML, servere web și baze de date. Verificați Piața AWS pentru a vedea toate AMI-urile grozave de acolo!

Îmi place imaginea Amazon Linux 2, dar puteți căuta orice tip de imagine, inclusiv Ubuntu, Centos sau orice număr de Bitnami imagini.

Notă rapidă aici. Îmi plac imaginile Bitnami. Toate sunt minunate și, dacă sunteți în căutarea implementării oricărui tip de aplicație web precum Ghost, WordPress, Nginx sau chiar aplicații mai complexe precum Redash sau Airflow, le recomand cu adevărat.

Expertul EC2 – Alegeți tipul de instanță

Mă duc cu cel gratuit, deoarece intenționez să ucid acest lucru, dar dacă folosiți de fapt această instanță EC2 pentru ceva important, veți dori să adăugați mai multă putere. Dacă aveți nevoie de ceva care implică internet, cum ar fi transferul de date, asigurați-vă că acordați atenție capacităților de internet și alegeți ceva în intervalul moderat.

1611551709 752 Cum sa spinati un server la distanta pe AWS

Derulați în jos și alegeți „Lansare” pentru a lansa cu setările implicite sau „Configurați instanța” pentru a adăuga în configurații suplimentare, cum ar fi schimbarea dimensiunii sistemului de fișiere rădăcină, alegerea unui VPC sau adăugarea datelor utilizatorului.

Expertul EC2 – Adăugați etichete

Când începeți, acest lucru nu contează prea mult, dar pe măsură ce începeți cu AWS, veți dori să vă asigurați că toate instanțele dvs. au, cel puțin, Name Etichete. Acest lucru vă va permite să căutați mai ușor instanțele dvs. și să faceți lucruri frumoase, cum ar fi crearea de grupuri de resurse pentru a grupa serviciile AWS.

În meniul expertului selectați „Adăugați etichete”. Nu vă faceți griji, puteți comuta între pași în vrăjitor ori de câte ori doriți.

1611551710 670 Cum sa spinati un server la distanta pe AWS

Expertul EC2 – Configurați grupul de securitate

Înainte de a termina, vom configura grupul de securitate, ceea ce definește regulile de acces. AWS va crea un grup de securitate pentru dvs. sau puteți alege deja unul. Implicit este să deschideți portul 22 pentru SSH, dar dacă îl veți folosi pentru orice aplicație web sau bază de date, va trebui să deschideți și acele porturi.

1611551710 853 Cum sa spinati un server la distanta pe AWS

Vrăjitorul EC2 – LANSARE

Acum, că am spus AWS ce vrem, să lansăm instanța noastră! Faceți clic pe Revizuire și lansare. Veți primi o fereastră pop-up care vă va solicita ce cheie SSH doriți. De asemenea, puteți crea o nouă pereche de chei SSH aici.

1611551711 489 Cum sa spinati un server la distanta pe AWS

Expertul EC2 – Pagina de confirmare

După lansare, veți fi adus la o pagină de confirmare cu ID-ul de instanță EC2.

1611551712 321 Cum sa spinati un server la distanta pe AWS

Tabloul de bord EC2 – Obțineți adresa IP

Iată-ne! Acum nu mai rămâne decât să așteptăm ca instanța noastră să fie gata și SSH să fie terminat.

1611551712 826 Cum sa spinati un server la distanta pe AWS

O.K! Acum trebuie doar să trimitem SSH la instanța noastră. Detaliile pentru acest lucru vor fi ușor diferite, în funcție de tipul de instanță pe care l-ați ales.

Aceasta presupune că ați descărcat perechea de chei numită my-remote-server.pem și l-a mutat în ~/.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

Asta e! Acum aveți un server de la distanță pe cloud!

Rotiți o instanță EC2 cu biblioteca Boto3 Python

Avertisment complet aici. Acest lucru depășește cu mult ceea ce aș face în mod normal cu biblioteca boto3. Pentru orice lucru dincolo de lansarea unei instanțe EC2, aș recomanda utilizarea consolei sau utilizarea unei infrastructuri ca instrument de cod, cum ar fi Cloudformare sau Terraform. Dar când începeți este foarte important să înțelegeți fundamentele.

Am, de asemenea, o nevoie obsesivă de a scrie rapoarte pentru absolut orice. Simțiți-vă liber să eliminați dacă nu sunteți la fel de paranoic. 😉

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()

Învelire

Asta este tot ce trebuie să știți pentru a începe să creați servere la distanță în cloud! Ce tipuri de proiecte doriți să implementați în cloud?