Membuat autoscaling instance pada openstack memanfaatkan layanan heat dan ceilometer

Heat autoscaling merupakan fitur tambahan pada openstack heat yang berfungsi untuk melakukan autoscaling pada sebuah mesin virtual. Komponen utama pada autoscaling adalah layanan orchestration. orchestration memungkinkan untuk mendefinisikan parameter atau aturan mengunakan template YAML yang mudah untuk dibaca. Pada aturan tersebut dapat diintegrasikan dengan layanan telemetri, sehingga ketika aturan tersebut sudah sesuai dengan aturan di layanan telemetri, maka telemetri dapat memberikan perintah ke heat orchestration untuk menambah atau mengurangi instance.

Sebelum mencoba membuat autoscaling ini, anda harus menginstall openstack bisa di coba disini.

tentunya anda akan menanyakan, kenapa kita butuh autoscaling? kapan kita memanfaatkan autoscaling? dan seterusnya…. ya pokoknya banyak pertanyaanlah :P,,,,,,

Sebelum kita membahas bagaimana konfigurasi autoscaling, kita juga harus mencari akar masalah kenapa  autoscaling itu dibutuhkan,,, ayoo kita kupas 😀

Analisis Masalah

  • Variable Demand

Pada analisis ini lebih kearah penggunaan aplikasi website yang digunakan dalam rentang waktu tertentu. Penggunaan aplikasi website tersebut digunakan selama seminggu dengan instensitas yang rendah pada awal dan akhir minggu, sedangkan pertengahan minggu banyak user yang mengakses sehingga penggunaan website meningkat secara signifikan.

Gambar1

  • Secara tradisional untuk mengatasi perubahan kapasitas pada gambar 1 terdapat dua cara yaitu menambahkan server sehingga aplikasi selalu memiliki kapasitas yang cukup untuk memenuhi permintaan seperti pada gambar 2. Namun kelemahan dari pilihan ini adalah terdapat hari dimana suatu aplikasi tidak membutuhkan kapasitas sebanyak itu. Penambahan kapasitas tidak dipakai secara maksimal dan pada dasarnya hanya meningkatkan biaya supaya aplikasi tetap berjalan.

Gambar2

  • pilihan kedua adalah memiliki kapasitas yang cukup untuk menangani permintaan rata-rata pada aplikasi. Pilihan ini lebih murah karena tidak perlu membeli server yang hanyak digunakan sesekali saja. Namun terdapat resiko terhadap user yang mengakses jika permintaan di server sedang melebihi kapasitasnya, maka proses permintaan user akan terganggu. seperti pada gambar 3

Gambar3

  • Dengan menambahkan autoscaling ke aplikasi ini, maka terdapat pilihan ketiga yang lebih efektif dan efisien. Karena instance akan terbentuk jika hanya diperlukan saja dan instance akan diberhentikan ketika sudah tidak dibutuhkan lagi. Sehingga dengan solusi yang ketiga ini memiliki arsitektur yang hemat biaya dan mempercepat layanan tanpa campur tangan admin. seperti pada gambar 4

Gambar4

Analisis Fungsional

secara fungsional autoscaling dapat diterapkan sebagai berikut:

  1. Autoscaling berguna ketika suatu aplikasi membutuhkan sumber daya tambahan untuk memenuhi jumlah permintaan dari pengguna aplikasi secara dinamis.

  2. Autoscaling dapat merancang arsitektur terukur yang secara otomatis meningkatkan atau memperkecil skala untuk memenuhi kebutuhan pengguna.

  3. Autoscaling tidak hanya berguna dalam penanganan lonjakan lalu lintas data ke server namun autoscaling juga berfungsi mempersiapkan infrastruktur untuk satu sampai sepuluh tahun kedepan.

Flowchart autoscaling

Work Flow autoscaling

Alur kerja pada autoscaling memiliki komponen utama yaitu scalingmain yang digunakan untuk memasukan sebuah kode ke beberapa mesin virtual di autoscaling group. Pada awalnya autoscaling group memiliki dua instance. secara detail penjelasan alur kerjanya seperti berikut :

  1. Tahap pertama adalah layanan heat menggunakan ssh untuk melakukan menyisipkan kode dari scalingmain ke mesin virtual.

  2. Setelaah itu layanan ceilometer menggunakan alarm untuk memonitoring utilitas cpu dari semua mesin virtual di scaling group

  3. Kemudian jika rata-rata utilitas cpu dari stack (scaling group) lebih besar atau sama dengan 80% maka layanan ceilometer akan mengaktifkan alarm cpu_high dan jika penggunaan rata-rata cpu kurang dari 15% maka ceilometer akan mengaktifkan alarm cpu_low.

  4. Jika utilitas cpu lebih dari 80% maka ceilometer akan memberikan notifikasi alarm action ke url scaling policy untuk melakukan autoscaling up kemudian akan terbentuk satu instance, Namun jika utilitas cpu kurang dari 15% maka ceilometer akan memberikan notifikasi alarm action ke url scaling policy untuk melakukan autoscaling down dengan menghapus satu instance.

  5. Layanan ceilometer akan memonitoring utilitas cpu di scaling group secara terus-menerus

wah lumayan banyak juga ya penjelesanya, okee………. sekarang kita coba buat template heat orchestration untuk menerapkan autoscaling di openstack 🙂

Membuat template network

sebelum menjalankan template ini, maka kita harus membuat netowrk external dengan nama net-ext, anda bisa coba disini

nama file template ini adalah network.yaml di host controller

heat_template_version: 2016-10-14

description: membuat network internal

parameters:
  network-publik:
    type: string
    label: network public for internet
    default: net-ext

  dns:
    type: comma_delimited_list
    label: dns nameserver
    default: "8.8.8.8"

resources:
#----------------------------------------#
#  membuat network privat                #
#----------------------------------------#
  network-internal:
    type: OS::Neutron::Net
    properties:
      name: network-internal

  subnet-internal:
    type: OS::Neutron::Subnet
    properties:
      name: subnet-internal
      network_id: { get_resource: network-internal }
      cidr: 192.168.200.0/24
      gateway_ip: 192.168.200.1
      dns_nameservers: { get_param: dns }

#----------------------------------------#
#  membuat virtual router                #
#----------------------------------------#
  router:
    type: OS::Neutron::Router
    properties:
      name: router0
      external_gateway_info:
        network: { get_param: network-publik }

  router-interface:
    type: OS::Neutron::RouterInterface
    properties:
      router_id: { get_resource: router}
      subnet_id: { get_resource: subnet-internal }

kemudian jalankan pada cli, sebelumnya harus jalankan environment

# openstack stack create -t network.yaml network-autoscaling
+---------------------+--------------------------------------+ 
| Field               | Value                                |
+---------------------+--------------------------------------+
| id                  | 6116df2b-269b-4d4f-b675-ee41c7dc3222 | 
| stack_name          | network-autoscaling                  | 
| description         | membuat network internal             | 
| creation_time       | 2017-07-11T11:17:09Z                 | 
| updated_time        | None                                 | 
| stack_status        | CREATE_IN_PROGRESS                   | 
| stack_status_reason | Stack CREATE started                 |
+---------------------+--------------------------------------+

jika stack sudah selesai terbentuk maka akan berstatus create_complate, kita bisa lihat hasilnya pada dashboard openstack

selain itu stack network.yaml yang sudah terbentuk akan muncul topologi stack pada heat orchestration

misalkan ada yang error waktu menjalankan file network.yaml, anda bisa lihat errornya pada events

Menjalankan Template Autoscaling

sebelum menjalankan autoscaling, kita harus mengkonfigurasi beberapa service diantaranya adalah layanan ceilometer pada controller yang berfungsi untuk memonitoring utilitas cpu.

#vim /etc/ceilometer/pipeline.yaml
-----
sources:     
    - name: meter_source       
    interval: 30       
    meters:           
       - "*"       
    sinks:           
     - meter_sink     
     - name: cpu_source       
    interval: 30       
    meters:           
      - "cpu" 
--------

selain itu mengkonfigurasi polling interval dan refresh pipeline pada /etc/ceilometer/ceilomter.conf

# vim /etc/ceilometer/ceilometer.conf
.....
refresh_pipeline_cfg = True
pipeline_polling_interval = 10
.....

setelah itu restart laynan ceilomternya

# systemctl restart openstack-ceilometer-*

sebelumnya kita harus membuat instance khusus nfs untuk menampung data website yang akan digunakan oleh instace autoscaling, sehingga ketika instance autoscaling terjadi down atau up, maka data website tidak akan terpengaruh karena tersimpan pada share storage

file nfs-server.yaml

heat_template_version: 2016-10-14
description: membuat instance nfs-server

parameters:
 flavor:
  type: string
  label: flavor untuk instance di project autoscaling
  default: f1.ubuntu

 key:
  type: string
  label: keypair untuk instance
  default: key-alan

 image:
  type: string
  label: image ubuntu-xenial untuk instance
  default: ubuntu-xenial

 sg:
  type: string
  label: security group utnuk nfs server
  default: sg-nfs

 network-internal:
  type: string
  label: network internal for instance
  default: network-internal


resources:
 vm-nfs:
  type: OS::Nova::Server
  properties:
   name: vm-nfs
   key_name: {get_param: key}
   security_groups: [{get_param: sg}]
   image: {get_param: image}
   flavor: {get_param: flavor}
   networks:
    - network: {get_param: network-internal}
   user_data_format: RAW
   user_data: |
    #!/bin/sh
      rm /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial main restricted universe multiverse" >> /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial-updates main restricted universe multiverse" >> /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial-security main restricted universe multiverse" >> /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial-backports main restricted universe multiverse" >> /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial-proposed main restricted universe multiverse" >> /etc/apt/sources.list
      apt-get update
      apt-get install nfs-kernel-server git
      mkdir /mnt/web
      sudo chown nobody:nogroup /mnt/web
      echo "/mnt/web 192.168.200.0/24(rw,sync,no_root_squash,no_all_squash)" >> /etc/exports
      git clone https://github.com/alanadiprastyo/autoscaling-web.git /mnt/web
      systemctl restart nfs-kernel-server

kemudian jalankan file nfs-server.yaml

# openstack stack create -t nfs-server.yaml nfs-server

setelah itu 3 template utnuk autoscaling diantaranya adalah web-server.yaml, mail.yaml dan env.yaml

file web-server.yaml

heat_template_version: 2016-10-14
description: Membuat web server group scaling

parameters:
  key:
    type: string
    label: key public for ssh

  image:
    type: string
    label: image

  flavor:
    type: string
    label: subnet-internal

  pool:
    type: string
    label: pool load balance

  network-internal:
    type: string
    label: subnet-internal

  subnet-internal:
    type: string
    label: subnet-internal

  net-ext:
    type: string
    label: network-external

  security_group1:
    type: string
    label: security-group

  metadata:
   type: json

resources:
  server:
    type: OS::Nova::Server
    properties:
      name: server
      key_name: { get_param: key }
      security_groups: [{get_param: security_group1}]
      metadata: {get_param: metadata}
      image: {get_param: image}
      flavor: {get_param: flavor}
      networks:
        - network: {get_param: network-internal}
      user_data_format: RAW
      user_data: |
        #!/bin/sh
        rm /etc/apt/sources.list
        echo "deb http://kambing.ui.ac.id/ubuntu/ xenial main restricted universe multiverse" >> /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial-updates main restricted universe multiverse" >> /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial-security main restricted universe multiverse" >> /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial-backports main restricted universe multiverse" >> /etc/apt/sources.list
	echo "deb http://kambing.ui.ac.id/ubuntu/ xenial-proposed main restricted universe multiverse" >> /etc/apt/sources.list
        apt-get update
        apt-get install -y apache2 htop stress nfs-common
        sed -i '13 i mount 192.168.200.9:/share /var/www/html' /etc/rc.local #ip 192.168.200.9 => ip nfs-server
        /etc/rc.local


#
# LBaaS V2 Member definition
#
  member:
    type: OS::Neutron::LBaaS::PoolMember
    properties:
      pool: { get_param: pool }
      address: { get_attr: [server, first_address] }
      protocol_port: 80
      subnet: { get_param: subnet-internal }

file env.yaml

resource_registry:
    "OS::Nova::Server::Webserver": web-server.yaml

file main.yaml

heat_template_version: 2016-10-14
description: Autoscaling dengan lbaas

parameters:
  flavor:
    type: string
    description: flavor untuk instance
    default: f1.ubuntu
    constraints:
      - custom_constraint: nova.flavor

  app_port:
    type: string
    description: Aplication TCP Port
    default: "80"

  key:
    type: string
    description: key publik ssh untuk instance
    default: "key1"

  image:
    type: string
    description: image OS untuk instance
    default: "ubuntu-xenial"
    constraints:
      - custom_constraint: glance.image

  network-internal:
    type: string
    description: network internal untuk instance
    default: "network-internal"
    constraints:
      - custom_constraint: neutron.network

  subnet-internal:
    description: Neutron SUB-Network
    default: "subnet-internal"
    type: string

  net-ext:
    type: string
    label: suubnet-internal
    default: net-ext


resources:

#----------------------------------------#
#  membuat security group                #
#----------------------------------------#
  security_group1:
    type: OS::Neutron::SecurityGroup
    properties:
      name: security_group1
      rules:
        - protocol: icmp
        - protocol: tcp
          port_range_min: 22
          port_range_max: 22
        - protocol: tcp
          port_range_min: 80
          port_range_max: 80

#----------------------------------------#
#  membuat scaling group                 #
#----------------------------------------#
  group:
    type: OS::Heat::AutoScalingGroup
    properties:
      cooldown: 60
      desired_capacity: 2
      max_size: 4
      min_size: 2
      resource:
        type: OS::Nova::Server::Webserver
        properties:
          metadata: {"metering.stack": {get_param: "OS::stack_id"}}
          pool: { get_resource: pool }
          flavor: { get_param: flavor }
          network-internal: { get_param: network-internal }
          subnet-internal: { get_param: subnet-internal }
          image: { get_param: image }
          security_group1: { get_resource: security_group1 }
          key: { get_param: key }
          net-ext: {get_param: net-ext}

#----------------------------------------#
#  membuat Monitor healt LBaas           #
#----------------------------------------#
  monitor:
    type: OS::Neutron::LBaaS::HealthMonitor
    properties:
      delay: 5
      type: HTTP
      timeout: 5
      max_retries: 3
      pool: { get_resource: pool }

#----------------------------------------#
#  membuat Pool LBaas                    #
#----------------------------------------#
  pool:
    type: OS::Neutron::LBaaS::Pool
    properties:
      name: pool
      lb_algorithm: ROUND_ROBIN
      protocol: HTTP
      listener: { get_resource: listener }

#----------------------------------------#
#  membuat Listner LBaas                 #
#----------------------------------------#
  listener:
    type: OS::Neutron::LBaaS::Listener
    properties:
      loadbalancer: { get_resource: lb }
      protocol: HTTP
      protocol_port: 80

#----------------------------------------#
#  membuat "load balancer" LBaas V2      #
#----------------------------------------#
  lb:
    type: OS::Neutron::LBaaS::LoadBalancer
    properties:
     name: lb
     vip_subnet: { get_param: subnet-internal }

#----------------------------------------#
#  membuat flaoting ip load balanceer    #
#----------------------------------------#
  floating_ip:
    type: OS::Neutron::FloatingIP
    properties:
      floating_network: { get_param: net-ext }
      port_id: { get_attr: [lb, vip_port_id ]}

#----------------------------------------#
#  membuat Scale Policy up & down        #
#----------------------------------------#
  scaleup_policy:
    type: OS::Heat::ScalingPolicy
    properties:
      adjustment_type: change_in_capacity
      auto_scaling_group_id: { get_resource: group }
      cooldown: 60
      scaling_adjustment: 1


  scaledown_policy:
    type: OS::Heat::ScalingPolicy
    properties:
      adjustment_type: change_in_capacity
      auto_scaling_group_id: { get_resource: group }
      cooldown: 300
      scaling_adjustment: -1

#----------------------------------------#
#  membuat Aodh Alarm for scaling        #
#----------------------------------------#
  cpu_alarm_high:
    type: OS::Ceilometer::Alarm
    properties:
      meter_name: cpu_util
      description: Scale-up if the average CPU >= 80% for 1 minute
      statistic: avg
      period: 60
      evaluation_periods: 1
      threshold: 80
      alarm_actions:
        - {get_attr: [scaleup_policy, alarm_url]}
      comparison_operator: gt
      matching_metadata: {'metadata.user_metadata.stack': {get_param: "OS::stack_id"}}

  cpu_alarm_low:
    type: OS::Ceilometer::Alarm
    properties:
      meter_name: cpu_util
      description: Scale-down if the average CPU < 15% for 5 minutes
      statistic: avg
      period: 300
      evaluation_periods: 1
      threshold: 15
      alarm_actions:
        - {get_attr: [scaledown_policy, alarm_url]}
      comparison_operator: lt
      matching_metadata: {'metadata.user_metadata.stack': {get_param: "OS::stack_id"}}

#----------------------------------------#
#  Outpu Heat Scaling                    #
#----------------------------------------#
outputs:
  Scale-UP-URL:
    value: {get_attr: [scaleup_policy, alarm_url]}
    description: Scale-UP ALARM URL
  Scale-DOWN-URL:
    value: {get_attr: [scaledown_policy, alarm_url]}
    description: Scale-DOWN ALARM URL
  Scale-UP-SIGNAL-URL:
    value: {get_attr: [scaleup_policy, signal_url]}
    description: Scale-UP Signal URL
  Scale-DOWN-SIGNAL-URL:
    value: {get_attr: [scaledown_policy, signal_url]}
    description: Scale-DOWN Signal URL
  LB-URL-VIP:
    value: {get_attr: [lb, vip_address]}
    description: VIP for our Load Balancer

pastikan atribut pada file untuk autoscaling tersebut sudah sesuai dengan environtment di openstack, seperti nama keypair, nama image dll.

pada file main.yaml berfungsi sebagai file autama autoscaling dimana didalamnya terdapat scale policy dan aodh alarm. pada scale policy berfungsi untuk menentukan ketika autoscaling up maka akan bertambah 1 instance berdasarkan scaling_adjustment: 1, dan ketika autoscaling down maka akan berkurang 1 instance berdasarkan scaling_adjustment: -1. dan pada aodh alarm berfungsi untuk pemicu yang akan arahkan ke scale policy, sehingga ketika utilitas cpu atau threshold lebih dari 80% selama periode 60 detik maka akan diteruskan ke scaleup policy , sebaliknya ketika rata-rata penggunaan cpu atau threshold kurang dari 15% selama 300 detik maka akan diteruskan ke scaledown policy.

tahap selanjutnya adalah menjalankan file autoscaling pada host controller

#openstack stack create vm-autoscaling -t main.yaml -e env.yaml

+---------------------+--------------------------------------+ 
| Field               | Value                                |
+---------------------+--------------------------------------+ 
| id                  | 5e04c8dd-c373-4927-9d73-76f87f213f09 |
| stack_name          | vm-autoscaling                       | 
| description         | Autoscaling dengan lbaas             | 
| creation_time       | 2017-07-12T14:19:49Z                 | 
| updated_time        | None                                 | 
| stack_status        | CREATE_IN_PROGRESS                   | 
| stack_status_reason | Stack CREATE started                 |
+---------------------+--------------------------------------+

setelah stack autoscaling terbentuk maka akan membentuk topologi komposit di dashboard openstack

selain itu pada openstack akan terbentuk 2 instance karena sudah diset disired capacity sama dengan 2.

setelah file autoscaling sudah berjalan maka tahap selanjutnya adalah menguji autoscaling tersebut apakah dapat berjalan dengan baik atau tidak,

Topologi awal terbentuk

Topologi setelah terjadi autoscaling up

Topologi setelah terjadi autoscaling down

Untuk lebih jelasnya, anda dapat melihat video demo nya dibawah ini

mungkin cukup sekian dulu, pembahasan autoscaling di openstack semoga bermanfaat. sebenarnya autoscaling tidak hanya di openstack namun bisa juga di jalankan pada public cloud seperti aws, google cloud platform ataupun rackspace.

Wassalamualaikum 🙂

About the author
Alan Adi Prastyo

Routecloud Networks

Information about Server, Linux and Computer Network.

Great! You’ve successfully signed up.

Welcome back! You've successfully signed in.

You've successfully subscribed to Routecloud Networks.

Success! Check your email for magic link to sign-in.

Success! Your billing info has been updated.

Your billing was not updated.