Copy dan Sharing Amazon Machine Images (AMI) di beda Region pada AWS

Written by Hakim on December 13, 2022

Overview:

Pada tulisan kali ini kita akan menyalin dan sharing ami antar region, pada kasus ini AMI yang ada di region Virginia akan di copy ke region Ohio. Karena AMI pada AWS ini melekat pada setiap region maka jika kita ingin menggunakan AMI berbeda region bisa menggunakan cara yang akan kita praktekkan pada tulisan ini. Adapun langkah-langkah yang akan dilakukan adalah sebagai berikut:

1. Copy AMI dari region virginia ke region Ohio

2. Sharing AMI

3. Hapus sumber daya

Prasyarat:

Akun AWS
AMI yang sudah di kustom dengan menginstall wordpress

Langkah-langkah:

Salin AMI

Klik kanan pada AMI
Klik Copy AMI

Pada destination: ohio
check encrypt
kms key: aws/ebs
copy AMI

Check pada region Ohio, lihat AMI sudah tercopy ke dalam region tersebut, pindah ke region Ohio kemudian perhatikan isi dari AMI.

Sharing AMI

Sekarang edit AMI menjadi publik, kembali ke region Virginia

Klik kanan AMI
Klik edit AMI permissions

pada AMI availability pilih public
Klik save changes

Perhatikan visibility pada AMI, visibility pada sudah berubah menjadi publik. Perlu di ketahui, disaat kita menyalin AMI secara default akan menjadi private, jika ingin menjadi publik bisa melakukan langkah-langkah seperti diatas.

Hapus sumber daya

Deregister AMI di region ohio
Deregister AMI di region virginia
Hapus snapshot di region ohio
Hapus snapshot di region virginia

Referensi:

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html

AWS Certified SysOps Administrator - Associate Course

Membuat Amazon Machine Images (AMI) pada AWS

Written by Hakim on December 10, 2022

Overview:

Pada tulisan kali ini kita akan membuat image yang sudah terinstall wordpress, sehingga image tersebut dapat digunakan untuk beberapa instance. Adapun langkah-langkah yang akan kita lakukan adalah sebagai berikut:

1. Membuat instance

2. Install wordpress, bisa dilihat pada tulisan sebelumnya

3. Install cowsay

4. Stop instance

5. Buat Image

6. Launch instance

Prasyarat:

Akun AWS
Wordpress
Terraform

Langkah-langkah:

Membuat Instance

Pada langkah ini bisa mengikuti menggunakan kode terraform untuk membuat instance, disini

Install Wordpress

Pada langkah ini bisa melihat pada tulisan sebelumnya, disini

Install cowsay

sudo yum install -y cowsay

edit header, jadi seperti ini:

sudo vi /etc/update-motd.d/40-cow

...
#!/bin/bash
echo "Amazon Linux 2 - Welcome"
...

sudo chmod 755 /etc/update-motd.d/40-cow

sudo rm /etc/update-motd.d/30-banner

sudo update-motd

sudo reboot

Amazon Linux 2 - Welcome

Stop Instance

Stop instance sebelum membuat image.

Create Image

Klik kanan pada instance
Pilih image and templates
Pilih create image

Isi detail image
AhaTemplateWordpress
Klik Create Image

Kemudian lihat snapshot

Lihat AMI

Launch Instance

Klik kanan ami
Klik launch instance from ami

isi detail instance
launch instance

Masuk kedalam instance

Hapus sumber daya

Hapus sumberdaya yang sudah dibuat, mulai dari snapshot, image dan instance.

Terraform Code: Github

Referensi: AWS Certified SysOps Administrator - Associate Course

Melakukan Query pada Data Menggunakan Amazon Athena

Written by Hakim on December 04, 2022

Overview:

Amazon Athena merupakan layanan interaktif analitik tanpa server yang mana perngguna tidak perlu melakukan konfigurasi pada server. Athena dibangun diatas open source. Athena dapat digunakan untuk mengalasis data atau membangun aplikasi dari amazon S3 dan dari sumber data lainnya. Untuk lebih detail mengenai amazon athena, bisa dibaca disini.

Kali ini kita akan melakukan query pada data menggunakan data source dari open street map, untuk menampilkan data berdasarkan lokasi. Adapun langkah-langkah yang akan kita lakukan adalah:

1. Membuat S3 bucket

2. Membuat query athena

3. Menghapus sumber daya

Prasyarat:

Akun AWS
S3 bucket
Athena

Langkah-langkah:

Membuat S3

Buat S3 bucket dengan akses publik

Membuat Athena

1. Buat athena

Masuk ke service athena
Klik explore the query editor
Klik settings
Manage
Isi bucket s3
Isi aws account ID
Centang assign bucket owner
Save

2. Buat query untuk membuat database

CREATE DATABASE aha_db;

Jalankan query

Klik tanda plus untuk menambah query baru

3. Buat query untuk membuat tabel baru

CREATE EXTERNAL TABLE planet (
  id BIGINT,
  type STRING,
  tags MAP<STRING,STRING>,
  lat DECIMAL(9,7),
  lon DECIMAL(10,7),
  nds ARRAY<STRUCT<ref: BIGINT>>,
  members ARRAY<STRUCT<type: STRING, ref: BIGINT, role: STRING>>,
  changeset BIGINT,
  timestamp TIMESTAMP,
  uid BIGINT,
  user STRING,
  version BIGINT
)
STORED AS ORCFILE
LOCATION 's3://osm-pds/planet/';

Jalankan query

4. Tambah query baru, untuk menampilkan data

Select * from planet LIMIT 100;

Klik run

5. tambah query baru untuk menampilkan data berdasarkan tags, latitude dan longitude

SELECT * from planet
WHERE type = 'node'
  AND tags['amenity'] IN ('veterinary')
  AND lat BETWEEN -27.8 AND -27.3
  AND lon BETWEEN 152.2 AND 153.5;

Hapus sumber daya

1. Hapus table

DROP TABLE planet;

2. Hapus database

DROP DATABASE aha_db;

3. Hapus S3 bucket

Referensi:

https://aws.amazon.com/athena/

AWS Certified SysOps Administrator - Associate

DevOps Deployment Automation with Terraform, AWS and Docker (Part 1)

Written by Hakim on December 04, 2022

Project Architecture

Overview:

In this tutorials, we will create about devops deployment automation with terraform, AWS and Docker. The below is guide that we will create:

Setup dev environment.
Setup AWS.
Setup NGINX proxy.
Setup project app for deployment.
Setup terraform.

Prerequisites:

AWS account
Cost
Backend app (base on django)
GitLab CI/CD

Guide:

Setup Dev Environment

1. Install tools

Visual studio code, etc
AWS Vault
Install M odHeader (modify HTTP request and header)

Setup AWS

Give IAM user access to billing information, docs
Setup AWS IAM account

Create devops group with AdministratorAccess
Add user to devops group

Set MFA to IAM account
Setup AWS-vault
Create budget on AWS

Setup NGINX proxy

1. Setup GitLab account and SSH authentication, here
2. Create nginx proxy project on gitlab
3. Configure nginx proxy

Setting permission on CI/CD

Setting protected branches

Setting protected tag

Clone project to local laptop

4. Setup AWS for nginx proxy

Create new registry in Amazon ECR (Elastic Container Registry)

Create new policy in IAM for proxy

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:*"
            ],
            "Resource": "arn:aws:ecr:us-east-1:*:repository/recipe-app-api-proxy"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ecr:GetAuthorizationToken"
            ],
            "Resource": "*"
        }
    ]
}

Create IAM user, attach existing policy

5. Setup repository variables on Gitlab

Add variable AWS_ACCESS_KEY_ID
Add variable AWS_SECRET_ACCESS_KEY
Add variable ECR_REPO

6. Create nginx config files

vi default.conf.tpl
...
server {
    listen ${LISTEN_PORT};
    location /static {
         alias /vol/static;
    }    
    location / {
         uwsgi_pass              ${APP_HOST}:${APP_PORT};
         include                 /etc/nginx/uwsgi_params;
         client_max_body_size    10M;    
    }
}

vi uwsgi_params
...
uwsgi_param  QUERY_STRING       $query_string;
uwsgi_param  REQUEST_METHOD     $request_method;
uwsgi_param  CONTENT_TYPE       $content_type;
uwsgi_param  CONTENT_LENGTH     $content_length;

uwsgi_param  REQUEST_URI        $request_uri;
uwsgi_param  PATH_INFO          $document_uri;
uwsgi_param  DOCUMENT_ROOT      $document_root;
uwsgi_param  SERVER_PROTOCOL    $server_protocol;
uwsgi_param  REQUEST_SCHEME     $scheme;
uwsgi_param  HTTPS              $https if_not_empty;

uwsgi_param  REMOTE_ADDR        $remote_addr;
uwsgi_param  REMOTE_PORT        $remote_port;
uwsgi_param  SERVER_PORT        $server_port;
uwsgi_param  SERVER_NAME        $server_name;
...

vi entrypoint.sh
...
#!/bin/sh
set -e
envsubst < /etc/nginx/default.conf.tpl > /etc/nginx/conf.d/default.conf
nginx -g 'daemon off;'
...

7. Create nginx dockerfile

vi Dockerfile
...
FROM nginx/nginx-unprivileged:1-alpine
LABEL maintainer="maintainer@ha-go.com"

COPY ./default.conf.tpl /etc/nginx/default.conf.tpl
COPY ./uwsgi_params /etc/nginx/uwsgi-params

ENV LISTEN_PORT=8000
ENV APP_HOST=app
ENV APP_PORT=9000

USER root

RUN mkdir -p /vol/static
RUN chmod 755 /vol/static
RUN touch /etc/nginx/conf.d/default.conf
RUN chown nginx:nginx /etc/nginx/conf.d/default.conf

COPY ./entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

USER nginx

CMD ["/entrypoint.sh"]
...

8. Setup gitlab ci/cd pipeline build job

vi .gitlab-ci.yml
...
image: docker:19.03.5
services:
  - docker:19.03.5-dind

stages:
  - Build
  - Push

Build:
  stage: Build
  before_scripts: []
  scripts:
    - mkdir data/
    - docker build --compress -t proxy .
    - docker save --output data/image.tar proxy
  artifacts:
    name: image
    paths:
      - data/
...

9. Setup gitlab ci/cd pipeline push jobs

vi .gitlab-ci.yml
...
image: docker:19.03.5
services:
  - docker:19.03.5-dind
  
stages:
  - Build
  - Push
  
before_script:
   - apk add python3
   - pip3 install awscli==1.18.8
   - docker load --input data/image.tar
   - $(aws ecr get-login --no-include-email --region us-east-1)
   
Build:
  stage: Build
  before_script: []
  script:
    - mkdir data/
    - docker build --compress -t proxy .
    - docker save --output data/image.tar proxy
  artifacts:
    name: image
    paths:
      - data/
      
Push Dev:
  stage: Push
  script:
   - docker tag proxy:latest $ECR_REPO:dev
   - docker push $ECR_REPO:dev
  rules:
   - if: "$CI_COMMIT_BRANCH == 'main'"
   
Push Release:
  stage: Push
  script:
   - export TAGGED_ECR_REPO=$ECR_REPO:$(echo $CI_COMMIT_TAG | sed 's/-release//')
   - docker tag proxy:latest $TAGGED_ECR_REPO
   - docker push $TAGGED_ECR_REPO
   - docker tag $TAGGED_ECR_REPO $ECR_REPO:latest
   - docker push $ECR_REPO:latest
  rules:
     - if: "$CI_COMMIT_TAG =~ /^*-release/"
...

10. Test proxy pipeline

Create new branch
Create new tag

Setup project app for deployment

1. Create new project on gitlab
2. Fork this repo https://gitlab.com/LondonAppDev/recipe-app-api-devops-starting-code
3. Configure gitlab project

Select project > Settings > General >Visibility, project features, permissions > CI/CD > Only Project Members > Save changes.

Select project > Settings > CI/CD > General pipelines > uncheck Public pipelines > Save changes

add uWSGI server to project

cd scripts/
vi entrypoint.sh
...
#!/bin/sh

set -epython manage.py collectstatic --noinput
python manage.py wait_for_db
python manage.py migrate

uwsgi --socket :9000 --workers 4 --master --enable-threads --module app.wsgi
...

update Dockerfile to run entrypoint

vi Dockerfile
...
FROM python:3.7-alpine
LABEL maintainer="ha-go"

ENV PYTHONUNBUFFERED 1
ENV PATH="/scripts:${PATH}"
RUN pip install --upgrade pip

COPY ./requirements.txt /requirements.txt

RUN apk add --update --no-cache postgresql-client jpeg-dev
RUN apk add --update --no-cache --virtual .tmp-build-deps \
      gcc libc-dev linux-headers postgresql-dev musl-dev zlib zlib-dev
RUN pip install -r /requirements.txt
RUN apk del .tmp-build-deps

RUN mkdir /app

WORKDIR /app
COPY ./app /app
COPY ./scripts /scripts

RUN chmod +x /scripts/*
RUN mkdir -p /vol/web/media
RUN mkdir -p /vol/web/static

RUN adduser -D user

RUN chown -R user:user /vol/
RUN chmod -R 755 /vol/web

USER user

VOLUME /vol/web

CMD ["entrypoint.sh"]
...

vi .dockerignore
...
docker-compose.yml
README.md
.git/
.gitignore
vol/
deploy/
...

docker build -t .

configure static and media files in app settings

vi app/app/settings.py
...
STATIC_URL = '/static/static/'
MEDIA_URL = '/static/media/'
...

setup environment variable configuration

vi app/app/settings.py
...
SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'changeme')
DEBUG = bool(int(os.environ.get('DEBUG', 0)))
ALLOWED_HOSTS.extend(
    filter(
        None,
        os.environ.get('ALLOWED_HOSTS', '').split(',')
    )
)
...

Add dubug mode on docker-compose

vi docker-compose.yml
...
version: "3"

services:
  app:
    build:
      context: .
    ports:
      - "8000:8000"
    volumes:
      - ./app:/app
    command: >
      sh -c "python manage.py wait_for_db &&
             python manage.py migrate &&
             python manage.py runserver 0.0.0.0:8000"
    environment:
      - DB_HOST=db
      - DB_NAME=app
      - DB_USER=postgres
      - DB_PASS=supersecretpassword
      - DEBUG=1
    depends_on:
      - dbdb:
    image: postgres:10-alpine
    environment:
      - POSTGRES_DB=app
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=supersecretpassword
...

docker-compose up

4. Test proxy development locally

vi docker-compose-proxy.yml
...
version: '3.7'

services:
  app:
    build:
      context: .
    volumes:
      - ./app:/app
      - static_data:/vol/web
    environment:
      - DB_HOST=db
      - DB_NAME=app
      - DB_USER=postgres
      - DB_PASS=supersecretpassword
      - ALLOWED_HOSTS=127.0.0.1
    depends_on:
      - db

  proxy:
    image: proxy:latest
    depends_on:
      - app
    ports:
      - "8000:8000"
    volumes:
      - static_data:/vol/static

  db:
    image: postgres:10-alpine
    environment:
      - POSTGRES_DB=app
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=supersecretpassword

volumes:
  static_data:
...

docker-compose -f docker-compose-proxy.yml up

Testing access browser

localhost:8000

Setup Terraform

1. Install terraform

2. Create S3 bucket

Create bucket:
S3 service > create bucket > select region virginia (us-east-1)
Block all public access
Enable versioning on bucket
S3 service > Select bucket > properties > versioning > enable versioning > save

3. Create DynamoDB table

Create table
DynamoDB service > create table > table name > <your-table-name>-tf-state-lock > Primary key > LockID > create

4. Configure terraform

Pull repository

Add .gitignore file

vi .gitignore
...
### Terraform ###
# Local .terraform directories
**/.terraform/*

# .tfstate files
*.tfstate
*.tfstate.*

# Crash log files
crash.log

# Ignore any .tfvars files that are generated automatically for each Terraform run. Most
# .tfvars files are managed as part of configuration and so should be included in
# version control.
#
# example.tfvars
.tfvars
terraform.tfvars

# Ignore override files as they are usually used to override resources locally and so
# are not checked in
override.tf
override.tf.json
*_override.tf
*_override.tf.json

# Include override files you do wish to add to version control using negated pattern
# !example_override.tf

# Include tfplan files to ignore the plan output of command: terraform plan -out=tfplan
# example: *tfplan*

# End of https://www.gitignore.io/api/python,terraform
.vscode

Add terraform file

$ mkdir deploy
$ vi deploy/main.tf
...
terraform {
   backend "s3" {
      bucket = "aha-recipe-app-api-devops-tfstate"
      key = "recipe-app.state"
      region = "us-east-1"
      encrypt = true
      dynamodb_table = "recipe-app-api-devops-tf-state-lock"
   }
}

provider "aws" {
    region = "us-east-1"
    version = "~>3.72.0"
}

5. Setup docker compose for running terraform6

Add docker-compose

$ vi deploy/docker-compose.yml
version: '3.7'

services:
  terraform:
    image: hashicorp/terraform:1.1.3
    volumes:
      - .:/infra
    working_dir: /infra
    environment:
      - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
      - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
      - AWS_SESSION_TOKEN=${AWS_SESSION_TOKEN}

Initializa terraform

$ ./aws-vault-linux-amd64 exec aha-devops --duration=12h
Enter token for arn:aws:iam::618274166637:mfa/ha-go: 792021
$ docker-compose deploy/docker-compose.yml run --rm terraform init

6. Create terraform workspace

$ docker-compose deploy/docker-compose.yml run --rm terraform workspace list
$ docker-compose deploy/docker-compose.yml run --rm terraform workspace new dev
$ docker-compose deploy/docker-compose.yml run --rm terraform workspace list

Instalasi Wordpress di EC2 Instance AWS

Written by Hakim on December 03, 2022

Overview:

Pada tulisan kali ini kita akan menginstall wordpress di EC2 instance AWS. Adapun langkah-langkah yang akan dilakukan adalah sebagai berikut:

1. Buat instance EC2

2. Konfigurasi wordpress

3. Akses wordpress

4. Hapus instance

Prasyarat:

Akun AWS

Langkah-langkah:

Buat Instance EC2

Instalasi EC2 instance menggunakan script terraform, bisa dilihat disini.

Konfigurasi Wordpress

1. Masuk ke dalam instance

Masuk kedalam instance dengan SSH atau menggunakan instance connect

2. Setup environment variable

DBName='ahawordpress'
DBUser='ahawordpress'
DBPassword='In1r4ha514'
DBRootPassword='In1r4ha514'

3. Install software, webserver and app

sudo yum update -y
sudo yum install -y mariadb-server httpd wget
sudo amazon-linux-extras install -y lamp-mariadb10.2-php7.2 php7.2

4. Start service

sudo systemctl enable httpd
sudo systemctl enable mariadb
sudo systemctl start httpd
sudo systemctl start mariadb

5. Setup password mariadb

mysqladmin -u root password $DBRootPassword

6. Install wordpress

sudo wget http://wordpress.org/latest.tar.gz -P /var/www/html
cd /var/www/html
sudo tar -zxvf latest.tar.gz
sudo cp -rvf wordpress/* .
sudo rm -R wordpress
sudo rm latest.tar.gz

7. Konfigurasi wordpress

sudo cp ./wp-config-sample.php ./wp-config.php
sudo sed -i "s/'database_name_here'/'$DBName'/g" wp-config.php
sudo sed -i "s/'username_here'/'$DBUser'/g" wp-config.php
sudo sed -i "s/'password_here'/'$DBPassword'/g" wp-config.php   
sudo chown apache:apache * -R

8. Buat database wordpress

echo "CREATE DATABASE $DBName;" >> /tmp/db.setup
echo "CREATE USER '$DBUser'@'localhost' IDENTIFIED BY '$DBPassword';" >> /tmp/db.setup
echo "GRANT ALL ON $DBName.* TO '$DBUser'@'localhost';" >> /tmp/db.setup
echo "FLUSH PRIVILEGES;" >> /tmp/db.setup
mysql -u root --password=$DBRootPassword < /tmp/db.setup
sudo rm /tmp/db.setup

Akses wordpress

Akses browser dengan IP publik wordpress yang sudah dibuat sebelumnya.

Hapus Instance

Hapus instance wordpress yang sudah dibuat sebelumnya, agar tidak ada tagihan pada sumber daya yang sudah tidak digunakan.

Terraform code: Github

Referensi: AWS Certified SysOps Administrator - Associate

Membuat EBS Volume di Amazon Web Services

Written by Hakim on December 02, 2022

Overview:

Pada tulisan kali ini kita akan membuat EBS volume pada AWS, dengan beberapa skenario. EBS merupakan block storage yang ada pada service AWS, ia digunakan pada EC2 instance seperti hardisk yang bisa dicabut colok. EBS ini merupakan storage yang fleksibel yang mana kita bisa menambahkan kapasitas volume, mengubah kapasitas IOPS dan sebagainya. Adapun penjelasan lebih detail mengenai EBS Volume pada AWS bisa dibaca disini. Untuk langkah-langkah yang akan kita lakukan adalah sebagi berikut:

Membuat instance
Membuat EBS volume
Attach volume ke instance-0 (AZ-A)
Masuk kedalam instance
Attach volume ke instance-1 (AZ-A)
Masuk ke instance 2
Snapshot volume
Buat volume baru dari snapshot
Attach volume snapshot ke instance-2 (AZ-B)
Clean up (bersihkan sumber daya)

Prasyarat:

Akun AWS
Terraform
Region: us-east-1
VPC default atau VPC yang sudah dibuat sebelumnya disini
Availability Zone: us-east-1a (instance-1-2)
Availability Zone: us-east-1b (instance3)
Kode terraform, disini

Langkah-langkah:

Membuat Instance

Pada bagian ini kita akan membuat instance sebanyak 3 instance dengan detail:

ebs-test-instance-0 (availability zone A)
ebs-test-instance-1 (availability zone A
ebs-test-instance-2 (availability zone B)

Pada langkah ini kita menggunakan tool terraform untuk membuat instance. Adapun langkah-langkahnya bisa dilihat di repo Github. Jika ingin membuat manual juga bisa dilakukan, namun kali ini kita akan membuat instance dengan script terraform.

Mambuat EBS

1. Buat instance

Pilih menu volumes yang ada pada EBS
Klik create volume
Isi detail volume
Isi size 5 GiB
Pilih Availability Zone: us-east-1a
Klik Create volume

2. Attach volume ke instance-0

Klik kanan EBSTest
Klik Attach volume
Pilih instance-0

Masuk ke dalam Instance

1. Masuk kedalam instance-0

Jalankan command berikut:

[ec2-user@ip-10-16-55-192 ~]$ lsblk
NAME    MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
xvda    202:0    0   8G  0 disk 
└─xvda1 202:1    0   8G  0 part /
xvdf    202:80   0   5G  0 disk 
[ec2-user@ip-10-16-55-192 ~]$ sudo file -s /dev/xvdf
/dev/xvdf: data

[ec2-user@ip-10-16-55-192 ~]$ sudo mkfs -t xfs /dev/xvdf
meta-data=/dev/xvdf              isize=512    agcount=4, agsize=327680 blks
         =                       sectsz=512   attr=2, projid32bit=1
         =                       crc=1        finobt=1, sparse=0
data     =                       bsize=4096   blocks=1310720, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
log      =internal log           bsize=4096   blocks=2560, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0
[ec2-user@ip-10-16-55-192 ~]$ sudo file -s /dev/xvdf
/dev/xvdf: SGI XFS filesystem data (blksz 4096, inosz 512, v2 dirs)

[ec2-user@ip-10-16-55-192 ~]$ sudo mkdir /ebstest
[ec2-user@ip-10-16-55-192 ~]$ sudo mount /dev/xvdf /ebstest
[ec2-user@ip-10-16-55-192 ~]$ df -k
Filesystem     1K-blocks    Used Available Use% Mounted on
devtmpfs          485312       0    485312   0% /dev
tmpfs             494456       0    494456   0% /dev/shm
tmpfs             494456     468    493988   1% /run
tmpfs             494456       0    494456   0% /sys/fs/cgroup
/dev/xvda1       8376300 1635808   6740492  20% /
tmpfs              98892       0     98892   0% /run/user/0
tmpfs              98892       0     98892   0% /run/user/1000
/dev/xvdf        5232640   38244   5194396   1% /ebstest
[ec2-user@ip-10-16-55-192 ~]$ cd /ebstest

[ec2-user@ip-10-16-55-192 ebstest]$ sudo bash -c  "echo Test file > testfile.txt"
[ec2-user@ip-10-16-55-192 ebstest]$ ls
testfile.txt
[ec2-user@ip-10-16-55-192 ebstest]$ cat testfile.txt 
Test file

Reboot Instance

[ec2-user@ip-10-16-55-192 ebstest]$ sudo reboot

2. Masuk ke instance-0 kembali

[ec2-user@ip-10-16-55-192 ~]$ df -k
Filesystem     1K-blocks    Used Available Use% Mounted on
devtmpfs          485312       0    485312   0% /dev
tmpfs             494456       0    494456   0% /dev/shm
tmpfs             494456     440    494016   1% /run
tmpfs             494456       0    494456   0% /sys/fs/cgroup
/dev/xvda1       8376300 1639020   6737280  20% /
tmpfs              98892       0     98892   0% /run/user/1000

Terlihat pada hasil diatas, mountingan /ebstest terlepas, karena tidak di set auto mount, sehingga ketika di restart maka disk tidak persistent.

3. Set auto mount pada filesystem

Catat UUID

[ec2-user@ip-10-16-55-192 ~]$ sudo blkid /dev/xvdf
/dev/xvdf: UUID="35cff01e-2e03-4f68-8fec-34e79d60c013" TYPE="xfs"

Edit file /etc/fstab

[ec2-user@ip-10-16-55-192 ~]$ sudo vi /etc/fstab

[ec2-user@ip-10-16-55-192 ~]$ sudo mount -a

4. Stop instance-0

Attach Volume ke instance-1

1. Detach volume

Detach EBS volume dari instance-0

Klik kanan volume EBSTest
Klik Detach

2. Attach volume ke instance-1

Masuk ke dalam instance -1, jalankan perintah berikut:

[ec2-user@ip-10-16-54-184 ~]$ lsblk
NAME    MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
xvda    202:0    0   8G  0 disk 
└─xvda1 202:1    0   8G  0 part /
xvdf    202:80   0   5G  0 disk 
[ec2-user@ip-10-16-54-184 ~]$ sudo file -s /dev/xvdf
/dev/xvdf: SGI XFS filesystem data (blksz 4096, inosz 512, v2 dirs)
[ec2-user@ip-10-16-54-184 ~]$ sudo mkdir /ebstest
[ec2-user@ip-10-16-54-184 ebstest]$ sudo mount /dev/xvdf /ebstest
[ec2-user@ip-10-16-54-184 ebstest]$ df -k
Filesystem     1K-blocks    Used Available Use% Mounted on
devtmpfs          485312       0    485312   0% /dev
tmpfs             494456       0    494456   0% /dev/shm
tmpfs             494456     412    494044   1% /run
tmpfs             494456       0    494456   0% /sys/fs/cgroup
/dev/xvda1       8376300 1638788   6737512  20% /
tmpfs              98892       0     98892   0% /run/user/1000
/dev/xvdf        5232640   38248   5194392   1% /ebstest
[ec2-user@ip-10-16-54-184 ~]$ cd /ebstest/
[ec2-user@ip-10-16-54-184 ebstest]$ ls /ebstest/
testfile.txt
[ec2-user@ip-10-16-54-184 ebstest]$ cat testfile.txt 
Test file

Pada hasil diatas kita bisa lihat bahwa file testfile.txt yang sebelumnya kita buat diinstance-0 masih ada, itu dikarenakan EBS volume ini bersifat persistent, selama datanya tidak dihapus datanya masih tetap ada.

3. Stop instance-1

4. Detach volume dari instace-1

Snapshot Volume

Snapshot pada volume EBSTest ini kita lakukan agar instance-2 pada availability_zone B bisa menggunakan volume yang sebelumnya sudah kita buat.

Lantas kenapa harus menggunakan snapshot ?

Jawabannya adalah, karena kita tidak bisa menempelkan volume yang ada di avaialability zone A ke instance-2 yang berada pada availability zone B. EBS volume hanya bisa di attach pada availability zone yang sama, seperti yang sudah kita contohkan pada instance-0 dan instance-1 diatas, sehingga tidak bisa kalau di attach ke instance-2 karena berbeda availability zone.

Nah, untuk itulah kita lakukan snapshot terlebih dahulu, kemudian kita buat volume dari snapshot tersebut untuk diarahkan ke availability zone B, tempat dimana instance-2 berada.

Adapun cara kerja dari snapshot ini adalah ia akan mereplikasi datanya ke availability zone yang lain di dalam region yang sama. Snapshot memungkinkan kita untuk membuat volume di satu AZ kemudian dapat dipindahkan ke Availability Zone yang lain.

1. Buat snapshot

klik kanan volume EBSTest
Klik create snapshot
Isi deskripsi
Klik Create snapshot

Membuat Volume dari Snapshot

Masuk ke snapshot
Klik kanan snapshot
Klik Create volume from snapshot
Pilih Availability Zone B

Attach Volume ke instance-2

1. Attach volume

Masuk ke volumes
Klik kanan volume
Attach ke instance-2 di availability zone B

2. Masuk kedalam instance-2

Jalankan perintah berikut:

[ec2-user@ip-10-16-113-66 ~]$ lsblk
NAME    MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
xvda    202:0    0   8G  0 disk 
└─xvda1 202:1    0   8G  0 part /
xvdf    202:80   0   5G  0 disk 
[ec2-user@ip-10-16-113-66 ~]$ sudo file -s /dev/xvdf
/dev/xvdf: SGI XFS filesystem data (blksz 4096, inosz 512, v2 dirs)
[ec2-user@ip-10-16-113-66 ~]$ sudo mkdir /ebstest
[ec2-user@ip-10-16-113-66 ~]$ sudo mount /dev/xvdf /ebstest
[ec2-user@ip-10-16-113-66 ~]$  cd /ebstest
[ec2-user@ip-10-16-113-66 ebstest]$ ls
testfile.txt
[ec2-user@ip-10-16-113-66 ebstest]$ cat testfile.txt
Test file

Dari hasil diatas bisa dilihat bahwa data dari volume sebelumnya masih ada, sehingga instance dari availability zone yang berbeda dapat mengakses data tersebut dengan di snapshot terlebih dahulu.

3. Stop Instance

4. Detach volume