Jakiś czas temu zajmowaliśmy się deployem aplikacji na OpenShift. Dzisiaj zrobimy to samo, ale na najpopularniejszej chmurze, czyli AWS.

Sam deployment, podobnie jak w przypadku OpenShift, zrobimy za pomocą linii komend. Na tym etapie pominiemy opisywanie poszczególnych komponentów AWS, a skupimy się na tym, żeby nasza aplikacja działała w chmurze.

Aplikacja

Omówmy sobie najpierw aplikacje, którą będziemy wrzucać do chmury. Aplikacja znajduję się w tym miejscu. Jest to, podobnie jak w przypadku aplikacji, którą wrzucaliśmy na Openshift, najprostsza aplikacja na SpringBoocie z jednym kontrolerem RESTowym. Jedyną doatkową rzeczą, którą musimy zrobić to dodanie pliku application.properties, w którym dodajemy następującą linię.

server.port=${PORT:8080}

Elastic Beanstalk wymaga, aby aplikacja była dostępna na porcie 5000, a domyślnym portem dla aplikacji SpringBoot jest port 8080. Dodając powyższą linię w konfiguracji dajemy możliwość wstrzyknięcia wartości tej własności z zewnątrz.

Rejestracja

Pierwszym krokiem, który musimy zrobić jest oczywiście rejestracja w serwisie Amazona. Samo założenie konta jest darmowe. Płacimy jedynie za używanie usług AWSa. Na szczęście część funkcjonalności jest darmowe do pewnego zużycia transferu czy innych zasobów. I ta darmowa część powinna nam starczyć do deployu prostej aplikacji 🙂

Command Line Interface

Skoro mamy obsłużyć deployment przy pomocy linii komend to zdecydowanie przyda nam się CLI dla AWS, a konkretniej mówiąc Elastic Beanstalk CLI. Elastic Beanstalk jest usługą w ramach AWS, na którą będziemy deployować naszą aplikację.

Wchodzimy na tę stronę, a następnie korzystamy z załączonej instrukcji do instalacji EB CLI. W telegraficznym skrócie:

  1. Klonujemy repozytorium EB CLI
    git clone https://github.com/aws/aws-elastic-beanstalk-cli-setup.git
  2. Instalujemy EB CLI przy pomocy następującej komendy:
    .\aws-elastic-beanstalk-cli-setup\scripts\bundled_installer

I to w teorii powinno wystarczyć.

W praktyce wystąpił u mnie następujący problem:
No module named 'virtualenv'

Na szczęści w intrukcji mamy dział Troubleshooting, który pomoże nam w rozwiązaniu naszych problemów 🙂

W moim przypadku trzeba byłoby wykonać poniższe polecenia:
pip uninstall -y virtualenv
pip install virtualenv
python .\aws-elastic-beanstalk-cli-setup\scripts\ebcli_installer.py

Po tych ciężkich bojach powinniśmy mieć zainstalowane Elastic Beanstalk CLI.

Dla sprawdzenia wywołajmy następujące polecenie w linii komend:

eb --version

W odpowiedzi powinniśmy uzyskać informacje o wersji zainstalowanej biblioteki.

EB CLI 3.15.3 (Python 3.7.3)

AWS Secret Access Keys

Nadeszła pora na uwierzytelnienie w AWS. Będziemy robić to za pomocą sekretnych kluczy wygenerowanych w AWSie. Jest to rozwiązanie zdecydowanie bezpieczniejsze niż podawanie hasła bezpośrednio do naszego pliku konfiguracyjnego.

Aby stworzyć parę Access key ID – Secret Access Key musimy udać się na tę stronę i wybrać zakładkę Access keys.

Następnie klikamy Create New Access Key i otrzymujemy naszą parę.

create Access key ID - Secret Access Key pair
Tworzenie nowej pary Access key ID – Secret Access Key

Pamiętajmy, że jest to jedyny moment kiedy możemy skopiować wartość Serect Access Key.

Access key ID - Secret Access Key created
Jedyny moment kiedy możemy skopiować wartość Serect Access Key

Konfiguracja EB

Przyszła pora stworzenie pliku konfiguracyjnego dla Elastic Beanstalk.

Przechodzimy do katalogu z naszą aplikacją i wykonujemy następujące polecenie:

eb init

W pierwszej kolejności zostaniemy poproszeni o wybór regionu, w którym ma zostać umieszczona nasza aplikacja.

Select a default region
 1) us-east-1 : US East (N. Virginia)
 2) us-west-1 : US West (N. California)
 3) us-west-2 : US West (Oregon)
 4) eu-west-1 : EU (Ireland)
 5) eu-central-1 : EU (Frankfurt)
 6) ap-south-1 : Asia Pacific (Mumbai)
 7) ap-southeast-1 : Asia Pacific (Singapore)
 8) ap-southeast-2 : Asia Pacific (Sydney)
 9) ap-northeast-1 : Asia Pacific (Tokyo)
 10) ap-northeast-2 : Asia Pacific (Seoul)
 11) sa-east-1 : South America (Sao Paulo)
 12) cn-north-1 : China (Beijing)
 13) cn-northwest-1 : China (Ningxia)
 14) us-east-2 : US East (Ohio)
 15) ca-central-1 : Canada (Central)
 16) eu-west-2 : EU (London)
 17) eu-west-3 : EU (Paris)
 18) eu-north-1 : EU (Stockholm)
 19) ap-east-1 : Asia Pacific (Hong Kong)
 20) me-south-1 : Middle East (Bahrain)

Region w AWS jest miejsce gdzie fizycznie znajdują się serwery. Jak widać na liście Amazon posiada swój sprzęt w naprawdę wielu miejscach 🙂 Dla naszych potrzeb wybór konkretnego regionu nie jest specjalnie istotny, ale wybierzmy region, który znajduje się najbliżej nas – eu-west-2 : EU (London). W moim przypadku jest to region nr 16.

W następnym kroku będziemy musieli podać informacje o AWS Secret Keys, które wygenerowaliśmy chwilę wcześniej.

You have not yet set up your credentials or your credentials are incorrect
 You must provide your credentials.
(aws-access-id):

Podajemy nasze klucze i idziemy dalej.

Kolejny krok to miejsce gdzie musimy podać nazwę naszej aplikacji.

Enter Application Name
 (default is "aws-hello-world"):

Możemy pozostać przy domyślnej nazwie. Zatwierdzamy ją i idziemy do kolejnego kroku.

Teraz musimy wybrać język naszej aplikacji.

Select a platform.
1) Node.js
2) PHP
3) Python
4) Ruby
5) Tomcat
6) IIS
7) Docker
8) Multi-container Docker
9) GlassFish
10) Go
11) Java
12) Packer
(default is 1):

Wybieramy oczywiście Java i zatwierdzamy.

Następnie dostaniemy pytanie o wersje Javy.

Select a platform version.
1) Java 8
2) Java 7
(default is 1):

Wybieramy zatem pożądaną wersje Javy, w naszym przypadku Java 8 🙂

Teraz dostaniemy pytanie o to czy chcemy kontynuować z CodeCommit.

Do you wish to continue with CodeCommit? (y/N) (default is n):

CodeCommit jest serwisem kontroli wersji dostarczonym przez AWS. My nie chcemy z niego korzystać w tym momencie, więc wybieramy opcję domyślną, czyli ‘n’.

Kolejne pytanie jest o konfiguracje SSH.

Do you want to set up SSH for your instances?
(Y/n):

Wybieramy ‘Y’ po czym będziemy musieli wybrać istniejącą parę kluczy lub stworzyć nową.

Select a keypair.
1) key-pair-lantkowiak
2) my-ubuntu-key
3) my-windows-key
4) [ Create new KeyPair ]
(default is 3):

Jeżeli mamy potworzone klucze to zostaną one wyświetlone, żebyśmy mogli z nich skorzystać. Jeżeli nie, to pojawi się jedynie opcja z tworzeniem nowej pary kluczy. Podejmujemy wybór i zatwierdzamy.

W tym momencie w katalogu naszego projektu został wygenerowany następujący plik: .elasticbeanstalk\config.yml, który będzię wyglądał w następujący sposób:

branch-defaults:
  master:
    environment: null
    group_suffix: null
global:
  application_name: aws-hello-world
  branch: null
  default_ec2_keyname: my-windows-key
  default_platform: Java 8
  default_region: eu-west-2
  include_git_submodules: true
  instance_profile: null
  platform_name: null
  platform_version: null
  profile: eb-cli
  repository: null
  sc: git
  workspace_type: Application

Jak możemy zobaczyć jest to plik, który zawiera głównie rzeczy, które przed chwilą konfigurowaliśmy.

Budowanie i JAR do chmury

Zbudujmy teraz naszą aplikacje. To, na czym nam dokładnie zależy to uzyskania JARa, który będziemy deployować. Wykonajmy zatem następujące polecenie mavenowe:

mvn clean package

To powinno zbudować nam naszą paczkę, którą znajdziemy pod tą lokalizacją: target\hello-world-0.0.1-SNAPSHOT.jar.

W tym momencie musimy delikatnie zmodyfikować plik konfiguracyjny EB i dodać informacje o tym, gdzie znajduje JAR, który będzie deployowany. Robimy to przy pomocy takiego parametru:

deploy:
  artifact: target/hello-world-0.0.1-SNAPSHOT.jar

Więc nasz plik w tym momencie będzie miał taką postać:

branch-defaults:
  master:
    environment: null
    group_suffix: null
global:
  application_name: aws-hello-world
  branch: null
  default_ec2_keyname: my-windows-key
  default_platform: Java 8
  default_region: eu-west-2
  include_git_submodules: true
  instance_profile: null
  platform_name: null
  platform_version: null
  profile: eb-cli
  repository: null
  sc: git
  workspace_type: Application
deploy:
  artifact: target/hello-world-0.0.1-SNAPSHOT.jar

Tworzenie instancji i deploy

W końcu przyszedł moment, kiedy będziemy mogli stworzyć instancje EB i wrzucić na nią naszą aplikację.

W pierwszej kolejności stwórzmy środowisko Elastic Beanstalka. Do tego celu wykorzystamy poniższą komendę:

eb create --single

Dostaniemy pytania o nazwę środowiska oraz DNS CNAME. Obie wartości możemy w tym możemy zostawić domyślne.

Enter Environment Name
(default is aws-hello-world-dev):
Enter DNS CNAME prefix
(default is aws-hello-world-dev):

Po zatwierdzeniu nastąpi tworzenie środowiska oraz upload naszej aplikacji. Czynność ta może potrwać kilka minut 🙂

Gdy akcja się zakończy nasza aplikacja powinna być zdeployowana i gotowa do użytku 🙂

Aby to sprawdzić wystarczy, że wykowołamy poniższą komendę w terminalu:

eb open

Powinna nam się otworzyć nasza przeglądarka z adresem gdzie nasza aplikacja została zdeployowana, a z naszej aplikacji powiniśmy dostać ciepłe przywitanie 🙂

Powitanie z naszej aplikacji

Podsumowanie

Dzisiaj przebyliśmy dość długą drogę, aby zdeployować naszą aplikację na AWS. Na szczęście droga ta zakończyła się pełnym sukcesem 🙂

Na pierwszy rzut oka można stwierdzić, że deployment aplikacji wymaga trochę więcej konfiguracji niż w przypadku Opensfita, ale musimy pamiętać też, że AWS dostarcza nam o wiele większą funkcjonalność.