Scaling out¶

Buat lebih banyak tugas¶

Gunakan SSH dengan keypair SSH yang ada untuk login ke instance controller app-controller:

$ ssh -i ~/.ssh/id_rsa USERNAME@IP_CONTROLLER

Panggil antarmuka command-line faafo untuk meminta pembangkit lima fraktal besar.

$ faafo create --height 9999 --width 9999 --tasks 5

Jika Anda memeriksa muatan pekerja, Anda bisa melihat instance tidak berjalan dengan baik. Pada instance flavor CPU tunggal, rata-rata muatan lebih besar dari 1 berarti server berada pada kapasitas.

$ ssh -i ~/.ssh/id_rsa USERNAME@IP_WORKER uptime
10:37:39 up  1:44,  2 users,  load average: 1.24, 1.40, 1.36

Buat lebih banyak permintaan layanan API¶

Beban API adalah masalah yang sedikit berbeda dari yang sebelumnya mengenai kapasitas untuk bekerja. Kita bisa mensimulasikan banyak permintaan ke API, sebagai berikut:

Gunakan SSH dengan keypair SSH yang ada untuk login ke instance controller app-controller:

$ ssh -i ~/.ssh/id_rsa USERNAME@IP_CONTROLLER

Gunakan for loop until memanggil antarmuka command-line faafo untuk meminta kumpulan fraktal acak sebanyak 500 kali:

$ for i in $(seq 1 500); do faafo --endpoint-url http://IP_CONTROLLER create & done

Jika Anda memeriksa beban pada instance layanan API app-controller , Anda melihat instance tidak berjalan dengan baik. Pada instance flavor CPU tunggal Anda, rata-rata beban lebih besar dari 1 berarti server berkapasitas.

$ uptime
10:37:39 up  1:44,  2 users,  load average: 1.24, 1.40, 1.36

Jumlah permintaan sebenarnya berarti beberapa permintaan fraktal mungkin tidak sampai ke antrian pesan untuk diproses. Untuk memastikan bahwa Anda dapat mengatasi permintaan, Anda juga harus meningkatkan kemampuan API dari aplikasi Fractals.

Hapus aplikasi yang ada¶

Lanjutkan dan hapus instance dan kelompok keamanan yang ada yang Anda buat di bagian sebelumnya. Ingat, saat kejadian di awan tidak lagi berfungsi, lepaskan mereka dan ciptakan kembali sesuatu yang baru.

for instance in conn.list_nodes():
    if instance.name in ['all-in-one','app-worker-1', 'app-worker-2', 'app-controller']:
        print('Destroying Instance: %s' % instance.name)
        conn.destroy_node(instance)


for group in conn.ex_list_security_groups():
    if group.name in ['control', 'worker', 'api', 'services']:
        print('Deleting security group: %s' % group.name)
        conn.ex_delete_security_group(group)

Kelompok keamanan ekstra¶

Saat Anda mengubah topologi aplikasi Anda, Anda harus memperbarui atau membuat grup keamanan. Di sini, Anda menciptakan kembali kelompok keamanan yang dibutuhkan.

api_group = conn.ex_create_security_group('api', 'for API services only')
conn.ex_create_security_group_rule(api_group, 'TCP', 80, 80)
conn.ex_create_security_group_rule(api_group, 'TCP', 22, 22)

worker_group = conn.ex_create_security_group('worker', 'for services that run on a worker node')
conn.ex_create_security_group_rule(worker_group, 'TCP', 22, 22)

controller_group = conn.ex_create_security_group('control', 'for services that run on a control node')
conn.ex_create_security_group_rule(controller_group, 'TCP', 22, 22)
conn.ex_create_security_group_rule(controller_group, 'TCP', 80, 80)
conn.ex_create_security_group_rule(controller_group, 'TCP', 5672, 5672, source_security_group=worker_group)

services_group = conn.ex_create_security_group('services', 'for DB and AMQP services only')
conn.ex_create_security_group_rule(services_group, 'TCP', 22, 22)
conn.ex_create_security_group_rule(services_group, 'TCP', 3306, 3306, source_security_group=api_group)
conn.ex_create_security_group_rule(services_group, 'TCP', 5672, 5672, source_security_group=worker_group)
conn.ex_create_security_group_rule(services_group, 'TCP', 5672, 5672, source_security_group=api_group)

Fungsi pembantu IP mengambang¶

Tentukan fungsi singkat untuk menemukan yang tidak digunakan atau mengalokasikan IP mengambang. Ini menghemat beberapa baris kode dan mencegah Anda mencapai kuota IP mengambang Anda terlalu cepat.

def get_floating_ip(conn):
    '''A helper function to re-use available Floating IPs'''
    unused_floating_ip = None
    for floating_ip in conn.ex_list_floating_ips():
        if not floating_ip.node_id:
            unused_floating_ip = floating_ip
            break
    if not unused_floating_ip:
        pool = conn.ex_list_floating_ip_pools()[0]
        unused_floating_ip = pool.create_floating_ip()
    return unused_floating_ip

Memisahkan database dan message queue¶

Sebelum Anda mengurangi layanan aplikasi Anda, seperti layanan API atau pekerja, Anda harus menambahkan database pusat dan instance pengiriman app-services . Database dan antrian pesan akan digunakan untuk melacak keadaan fraktal dan untuk mengkoordinasikan komunikasi antara layanan.

userdata = '''#!/usr/bin/env bash
curl -L -s https://opendev.org/openstack/faafo/raw/contrib/install.sh | bash -s -- \
    -i database -i messaging
'''

instance_services = conn.create_node(name='app-services',
                                     image=image,
                                     size=flavor,
                                     ex_keyname='demokey',
                                     ex_userdata=userdata,
                                     ex_security_groups=[services_group])
instance_services = conn.wait_until_running([instance_services])[0][0]
services_ip = instance_services.private_ips[0]

Skala layanan API¶

Dengan beberapa pekerja yang memproduksi fraktal secepat mungkin, sistem harus dapat menerima permintaan fraktal secepat mungkin. Jika aplikasi kita menjadi populer, ribuan pengguna mungkin terhubung ke API untuk menghasilkan fraktal.

Berbekal security group, image, dan flavor size, Anda dapat menambahkan beberapa layanan API:

userdata = '''#!/usr/bin/env bash
curl -L -s https://opendev.org/openstack/faafo/raw/contrib/install.sh | bash -s -- \
    -i faafo -r api -m 'amqp://guest:guest@%(services_ip)s:5672/' \
    -d 'mysql+pymysql://faafo:password@%(services_ip)s:3306/faafo'
''' % { 'services_ip': services_ip }
instance_api_1 = conn.create_node(name='app-api-1',
                                  image=image,
                                  size=flavor,
                                  ex_keyname='demokey',
                                  ex_userdata=userdata,
                                  ex_security_groups=[api_group])
instance_api_2 = conn.create_node(name='app-api-2',
                                  image=image,
                                  size=flavor,
                                  ex_keyname='demokey',
                                  ex_userdata=userdata,
                                  ex_security_groups=[api_group])
instance_api_1 = conn.wait_until_running([instance_api_1])[0][0]
api_1_ip = instance_api_1.private_ips[0]
instance_api_2 = conn.wait_until_running([instance_api_2])[0][0]
api_2_ip = instance_api_2.private_ips[0]

for instance in [instance_api_1,  instance_api_2]:
    floating_ip = get_floating_ip(conn)
    conn.ex_attach_floating_ip_to_node(instance, floating_ip)
    print('allocated %(ip)s to %(host)s' % {'ip': floating_ip.ip_address, 'host': instance.name})

Layanan ini bersifat klien, sangat tidak seperti para pekerja mereka tidak menggunakan antrian pesan untuk mendistribusikan tugas. Sebagai gantinya, Anda harus memperkenalkan semacam mekanisme load balancing untuk berbagi permintaan yang masuk antara berbagai layanan API.

Solusi sederhana adalah memberi setengah dari satu alamat teman Anda dan setengah lainnya, namun solusi itu tidak berkelanjutan. Sebagai gantinya, Anda bisa menggunakan DNS round robin untuk melakukannya secara otomatis. Namun, jaringan OpenStack dapat menyediakan Load Balancing sebagai Service, yang mana Jaringan menjelaskan.

Skala pekerja¶

Untuk meningkatkan kapasitas keseluruhan, tambahkan tiga pekerja:

userdata = '''#!/usr/bin/env bash
curl -L -s https://opendev.org/openstack/faafo/raw/contrib/install.sh | bash -s -- \
    -i faafo -r worker -e 'http://%(api_1_ip)s' -m 'amqp://guest:guest@%(services_ip)s:5672/'
''' % {'api_1_ip': api_1_ip, 'services_ip': services_ip}
instance_worker_1 = conn.create_node(name='app-worker-1',
                                     image=image, size=flavor,
                                     ex_keyname='demokey',
                                     ex_userdata=userdata,
                                     ex_security_groups=[worker_group])
instance_worker_2 = conn.create_node(name='app-worker-2',
                                     image=image, size=flavor,
                                     ex_keyname='demokey',
                                     ex_userdata=userdata,
                                     ex_security_groups=[worker_group])
instance_worker_3 = conn.create_node(name='app-worker-3',
                                     image=image, size=flavor,
                                     ex_keyname='demokey',
                                     ex_userdata=userdata,
                                     ex_security_groups=[worker_group])

Menambahkan kapasitas ini memungkinkan Anda menangani jumlah permintaan fraktal yang lebih tinggi. Begitu instance pekerja ini dimulai, mereka mulai memeriksa antrian pesan untuk permintaan, mengurangi keseluruhan simpanan keseluruhan seperti pembukaan pendaftar baru di supermarket.

Proses ini jelas sangat manual. Mencari tahu bahwa kami membutuhkan lebih banyak pekerja dan kemudian memulai pekerjaan baru membutuhkan beberapa usaha. Idealnya sistem akan melakukan ini sendiri. Jika Anda membangun aplikasi Anda untuk mendeteksi situasi ini, Anda dapat memilikinya secara otomatis meminta dan menghapus sumber daya, yang menghemat usaha melakukan pekerjaan ini sendiri. Sebagai gantinya, layanan OpenStack Orchestration dapat memantau beban dan menghidupkan instance, jika sesuai. Untuk mengetahui cara mengaturnya, lihat Orchestration.