Pengantar arsitektur aplikasi fraktal

Pengantar arsitektur aplikasi fraktal

Bagian ini memperkenalkan arsitektur aplikasi dan menjelaskan bagaimana hal itu dirancang untuk memanfaatkan fitur awan secara umum dan OpenStack pada khususnya. Ini juga menjelaskan beberapa perintah di bagian sebelumnya.

Prinsip arsitektur aplikasi cloud

Aplikasi awan biasanya berbagi beberapa prinsip desain. Prinsip-prinsip ini mempengaruhi disain aplikasi Fractals.

Modularitas dan micro-services

Micro-services adalah pola desain penting yang membantu mencapai modularitas aplikasi. Memisahkan fungsi aplikasi logis menjadi layanan independen menyederhanakan perawatan dan penggunaan ulang. Komponen Decoupling juga mempermudah komponen skala individu secara selektif, sesuai kebutuhan. Selanjutnya, modularitas aplikasi adalah fitur aplikasi yang dibutuhkan yang dapat diukur dengan baik dan fault tolerant.

Skalabilitas

Aplikasi awan sering menggunakan banyak instance kecil daripada beberapa instance besar. Asalkan aplikasi cukup modular, Anda dapat dengan mudah mendistribusikan micro-service sebanyak mungkin sesuai kebutuhan. Arsitektur ini memungkinkan aplikasi tumbuh melewati batas yang diberlakukan oleh ukuran maksimum sebuah instance. Ini seperti mencoba memindahkan sejumlah besar orang dari satu tempat ke tempat lain; Hanya ada begitu banyak orang yang bisa Anda pakai di bus terbesar, tapi Anda bisa menggunakan jumlah bus atau mobil kecil yang tidak terbatas, yang hanya menyediakan kapasitas yang Anda butuhkan - dan tidak lebih.

Toleransi kesalahan

Dalam pemrograman awan, ada analogi terkenal yang dikenal sebagai "cattle vs pets". Jika Anda belum pernah mendengarnya, itu seperti ini:

Bila Anda berurusan dengan hewan peliharaan, Anda menamai dan merawat mereka. Jika mereka sakit, Anda merawat mereka kembali ke kesehatan, yang bisa menyulitkan dan sangat menyita waktu. Saat Anda berurusan dengan ternak, Anda memasang label bernomor di telinga mereka. Jika mereka sakit, Anda menurunkannya dan melanjutkan perjalanan.

Itu, seperti yang terjadi, adalah realitas baru pemrograman. Aplikasi dan sistem yang digunakan untuk dibuat di server besar dan mahal, dirawat oleh staf operasi yang berdedikasi untuk menjaga kesehatan mereka. Jika ada yang tidak beres dengan salah satu server tersebut, tugas staf adalah melakukan apa pun untuk memperbaikinya lagi dan menyimpan server dan aplikasinya.

Dalam pemrograman awan, sangat berbeda. Daripada server besar dan mahal, Anda memiliki mesin virtual yang bisa dipakai; Jika ada yang tidak beres, Anda mematikan server dan memutar yang baru. Masih ada staf operasi, tapi bukannya mengelola server individual kembali ke kesehatan, tugas mereka adalah memantau kesehatan keseluruhan sistem.

Ada keuntungan pasti arsitektur ini. Sangat mudah untuk mendapatkan server "new", tanpa masalah yang pasti muncul saat server telah berjalan dan berjalan selama berbulan-bulan, atau bahkan bertahun-tahun.

Seperti halnya infrastruktur klasik, kegagalan infrastruktur awan (hardware, jaringan, dan perangkat lunak) yang tidak dapat dihindari tidak dapat dihindari. Saat merancang awan, sangat penting aplikasi Anda dirancang untuk lingkungan tempat terjadi kegagalan setiap saat. Ini mungkin terdengar seperti pertanggungjawaban, tapi tidak demikian; Dengan merancang aplikasi Anda dengan tingkat toleransi kesalahan yang tinggi, Anda juga membuatnya tahan lama, dan lebih mudah beradaptasi, dalam menghadapi perubahan.

Toleransi kesalahan sangat penting untuk aplikasi berbasis cloud.

Otomatisasi

Jika sebuah aplikasi dimaksudkan untuk secara otomatis naik turun untuk memenuhi permintaan, maka tidak mungkin ada langkah manual dalam proses penggelaran komponen aplikasi apapun. Otomasi juga mengurangi waktu untuk pemulihan aplikasi Anda jika terjadi kegagalan komponen, meningkatkan toleransi dan ketahanan kesalahan.

Programmatic interfaces (APIs)

Seperti banyak aplikasi cloud, aplikasi Fractals memiliki RESTful API. Anda dapat menghubungkannya secara langsung dan menghasilkan fraktal, atau Anda dapat mengintegrasikannya sebagai komponen aplikasi yang lebih besar. Setiap saat antarmuka standar seperti API tersedia, pengujian otomatis menjadi jauh lebih layak, meningkatkan kualitas perangkat lunak.

Arsitektur aplikasi fraktal

Aplikasi Fractals dirancang dengan prinsip-prinsip dari subbagian sebelumnya. Anda akan mencatat itu di Mulai, kami menerapkan aplikasi dengan gaya all-in-one, pada satu mesin virtual. Ini bukan praktik yang baik, tapi karena aplikasinya menggunakan layanan mikro untuk memisahkan fungsi aplikasi logis, kita bisa mengubahnya dengan mudah.

digraph {
  API -> Database [color=green];
  API -> Database [color=orange];
  Database -> API [color=red];
  API -> Webinterface [color=red];
  API -> "Queue Service" [color=orange];
  "Queue Service" -> Worker [color=orange];
  Worker -> API [color=green];
}

Pesan antrian digunakan untuk memudahkan komunikasi antara layanan aplikasi Fraktal. Aplikasi Fraktal menggunakan work queue (atau task queue) untuk mendistribusikan task (tugas) ke layanan pekerja.

Pesan antrian bekerja dengan cara yang mirip dengan antrean (atau berbaris, bagi kita di sisi lain lautan) di bank yang dilayani oleh beberapa pegawai. Antrian pesan dalam aplikasi kami memberikan umpan permintaan kerja yang dapat dilakukan satu per satu oleh pekerja, apakah ada satu layanan pekerja ataupun ratusan di antaranya.

Ini adalah sebuah useful pattern untuk banyak aplikasi awan yang memiliki daftar panjang permintaan masuk dan kumpulan sumber daya untuk melayani mereka. Ini juga berarti bahwa seorang pekerja mungkin mogok dan tugas akan diproses oleh pekerja lain.

Catatan

The RabbitMQ getting started tutorial memberikan pengenalan yang bagus untuk pesan antrian.

digraph {
  rankdir=LR;
  Queue [shape="doublecircle"];
  API -> Queue;
  Queue -> "Worker 1";
  Queue -> "Worker 2";
}

Layanan pekerja mengkonsumsi pesan dari antrian kerja dan kemudian memprosesnya untuk membuat file image fraktal yang sesuai.

Tentu saja ada juga antarmuka web yang menawarkan cara yang lebih ramah untuk mengakses API untuk melihat image fraktal yang dibuat, dan antarmuka command line yang sederhana.

screenshot of the webinterface

Ada juga beberapa storage back end (untuk menyimpan image fraktal yang dihasilkan) dan komponen basis data (untuk menyimpan keadaan tugas), namun kami akan membicarakan hal-hal tersebut di Make it durable dan Block Storage masing-masing.

Bagaimana aplikasi Fractals berinteraksi dengan OpenStack

Magic revisited

Jadi apa sebenarnya permintaan itu di akhir bagian sebelumnya? Mari kita lihat lagi. Dalam subbagian ini, kami hanya menjelaskan apa yang telah Anda lakukan di bagian sebelumnya; Anda tidak perlu menjalankan perintah ini lagi.

userdata = '''#!/usr/bin/env bash

curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \
-i faafo -i messaging -r api -r worker -r demo
'''

instance_name = 'all-in-one'
testing_instance = conn.create_server(wait=True, auto_ip=False,
    name=instance_name,
    image=image_id,
    flavor=flavor_id,
    key_name=keypair_name,
    security_groups=[sec_group_name],
    userdata=userdata)

Kami menjelaskan image and flavor di :doc: getting_started, jadi pada bagian berikut, kami akan menjelaskan parameter lainnya secara rinci, termasuk ex_userdata (cloud-init) dan ex_keyname (key pairs).

Perkenalan pada cloud-init

cloud-init adalah alat yang melakukan tugas konfigurasi instance saat boot instance awan, dan dipasang pada sebagian besar image awan. ex_userdata, yang dilewatkan ke create_node, adalah data konfigurasi yang dilewatkan ke cloud-init.

Dalam hal ini, kami menyajikan sebuah skrip shell sebagai userdata. Ketika create_node Menciptakan instance, cloud-init Mengeksekusi skrip shell di variable userdata.

Bila kunci publik SSH diberikan selama pembuatan instance, awan init memasang kunci ini di akun pengguna. (Nama pengguna bervariasi di antara image awan.) Lihat Obtaining Images bagian dari panduan image untuk pedoman tentang nama pengguna yang harus Anda gunakan saat SSHing. Jika Anda masih mengalami masalah saat log in, mintalah provider awan untuk mengkonfirmasi nama pengguna.

userdata = '''#!/usr/bin/env bash

curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \
-i faafo -i messaging -r api -r worker -r demo
'''

Setelah instance dibuat, unduhan cloud-init dan jalankan skrip yang disebut install.sh. Script ini menginstal aplikasi Fractals. Cloud-init bisa mengkonsumsi script bash dan sejumlah tipe data yang berbeda. Anda bahkan bisa menyediakan beberapa jenis data. Anda dapat menemukan lebih banyak informasi tentang cloud-init di official documentation.

Pengantar key pair (pasangan kunci)

Keamanan penting bila menyangkut instance Anda; Anda tidak bisa memiliki siapa pun yang mengaksesnya. Untuk mengaktifkan masuk ke sebuah instance, Anda harus menyediakan kunci publik dari pasangan kunci SSH selama pembuatan instance. Pada bagian pertama, Anda membuat dan mengunggah pasangan kunci ke OpenStack, dan cloud-init memasangnya untuk akun pengguna.

Bahkan dengan kunci di tempat, bagaimanapun, Anda harus memiliki peraturan kelompok keamanan yang sesuai untuk mengakses instance Anda.

Pengantar kelompok keamanan

Kelompok keamanan adalah kumpulan aturan akses jaringan yang diterapkan pada jaringan instance. Secara default, hanya lalu lintas jalan keluar (outbound) yang diperbolehkan. Anda harus secara eksplisit mengaktifkan akses jaringan masuk (inbound) dengan membuat aturan kelompok keamanan.

Peringatan

Menghapus aturan egress yang dibuat oleh OpenStack akan menyebabkan jaringan instance Anda terputus.

Mulailah dengan membuat grup keamanan untuk instance all-in-one dan menambahkan aturan yang sesuai, seperti HTTP (port TCP 80) dan SSH (port TCP 22):

sec_group_name = 'all-in-one'
conn.create_security_group(sec_group_name, 'network access for all-in-one application.')
conn.create_security_group_rule(sec_group_name, 80, 80, 'TCP')
conn.create_security_group_rule(sec_group_name, 22, 22, 'TCP')

Anda dapat mencantumkan kelompok keamanan yang tersedia dengan:

sec_groups = conn.list_security_groups()
for sec_group in sec_groups:
    print(sec_group)

Setelah membuat aturan atau grup, Anda juga dapat menghapusnya:

conn.delete_security_group_rule(rule_id)
conn.delete_security_group(sec_group_name)

Untuk melihat grup keamanan mana yang berlaku untuk sebuah instance, Anda dapat:

conn.get_openstack_vars(testing_instance)['security_groups']

name: 'all-in-one',
description: 'network access for all-in-one application.',
security_group_rules:
-   direction: 'ingress',
    protocol': 'tcp',
    remote_ip_prefix: '0.0.0.0/0',
    port_range_max: 22,
    security_group_id: '83aa1bf9-564a-47da-bb46-60cd1c63cc84',
    port_range_min: 22,
    ethertype: 'IPv4',
    id: '5ff0008f-a02d-4b40-9719-f52c77dfdab0',
-   direction: 'ingress',
    protocol: 'tcp',
    remote_ip_prefix: '0.0.0.0/0',
    port_range_max: 80,
    security_group_id: '83aa1bf9-564a-47da-bb46-60cd1c63cc84',
    port_range_min: 80,
    ethertype: 'IPv4',
    id: 'c2539e49-b110-4657-bf0a-7a221f5e9e6f',
id: '83aa1bf9-564a-47da-bb46-60cd1c63cc84'

Setelah Anda mengkonfigurasi izin, Anda harus tahu di mana mengakses aplikasi.

Pengantar Floating IP (IP Mengambang)

Seperti dalam TI tradisional, instance awan diakses melalui alamat IP yang diberikan OpenStack. Bagaimana ini sebenarnya dilakukan tergantung pada pengaturan jaringan untuk awan Anda. Dalam beberapa kasus, Anda hanya akan mendapatkan alamat IP rout-able internet yang diberikan langsung ke instance Anda.

Cara yang paling umum untuk awan OpenStack untuk mengalokasikan alamat IP Internet rout-able ke instance, bagaimanapun, adalah melalui penggunaan floating IP. Floating IP adalah alamat yang ada sebagai entitas tersendiri, dan dapat dikaitkan dengan antarmuka jaringan instance yang spesifik. Bila alamat floating IP dikaitkan dengan antarmuka jaringan instance, OpenStack re-directs traffic yang terikat alamat tersebut ke alamat alamat antarmuka jaringan internal instance. Provider awan Anda umumnya akan menawarkan kolam floating IP untuk Anda gunakan.

Untuk menggunakan floating IP, Anda harus mengalokasikan IP ke proyek Anda terlebih dulu, kemudian mengaitkannya ke antarmuka jaringan instance Anda.

Catatan

Mengalokasikan sebuah floating IP ke sebuah instance tidak mengubah alamat IP dari instance, menyebabkan OpenStack untuk menetapkan aturan terjemahan jaringan untuk mengizinkan sebuah additional alamat IP.

unused_floating_ip = conn.available_floating_ip()

Sekarang Anda memiliki alamat floating IP yang tidak terpakai yang dialokasikan untuk proyek Anda, kaitkan ke sebuah instance.

conn.add_ip_list(testing_instance, [unused_floating_ip['floating_ip_address']])

Itu membawa kita ke tempat kita berakhir di akhir Mulai. Tapi kemana kita pergi dari sini?

Memisahkan layanan di beberapa instance

Kami telah berbicara tentang memisahkan fungsi menjadi layanan mikro yang berbeda, dan bagaimana hal itu memungkinkan kami memanfaatkan arsitektur awan. Sekarang mari kita lihat itu beraksi.

Sisa tutorial ini tidak akan mereferensikan all-in-one instance yang Anda buat di bagian pertama. Luangkan waktu untuk menghapus instance ini.

Mudah untuk membagi layanan menjadi beberapa instance. Kita akan membuat instance controller yang disebut app-controller, yang menghosting layanan API, database, dan pesan. Kami juga akan membuat instance pekerja yang disebut app-worker-1, yang hanya menghasilkan fraktal.

Langkah pertama adalah memulai instance controller. Instance memiliki layanan API, database, dan layanan pesan, seperti yang dapat Anda lihat dari parameter yang dikirimkan ke skrip instalasi.

Parameter Deskripsi Values
-i Instal layanan messaging (install RabbitMQ) and faafo (install the Faafo app).
-r Enable/start something api (enable and start the API service), worker (enable and start the worker service), dan demo (run the demo mode to request random fractals).
worker_group_name = 'worker'
if conn.search_security_groups(worker_group_name):
    print('Security group \'%s\' already exists. Skipping creation.' % worker_group_name)
else:
    worker_group = conn.create_security_group(worker_group_name, 'for services that run on a worker node')
    conn.create_security_group_rule(worker_group['name'], 22, 22, 'TCP')

controller_group_name = 'control'
if conn.search_security_groups(controller_group_name):
    print('Security group \'%s\' already exists. Skipping creation.' % controller_group_name)
else:
    controller_group = conn.create_security_group(controller_group_name, 'for services that run on a control node')
    conn.create_security_group_rule(controller_group['name'], 22, 22, 'TCP')
    conn.create_security_group_rule(controller_group['name'], 80, 80, 'TCP')
    conn.create_security_group_rule(controller_group['name'], 5672, 5672, 'TCP', remote_group_id=worker_group['id'])

userdata = '''#!/usr/bin/env bash
curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \
    -i messaging -i faafo -r api
'''

instance_controller_1 = conn.create_server(wait=True, auto_ip=False,
    name='app-controller',
    image=image_id,
    flavor=flavor_id,
    key_name=keypair_name,
    security_groups=[controller_group_name],
    userdata=userdata)

unused_floating_ip = conn.available_floating_ip()

conn.add_ip_list(instance_controller_1, [unused_floating_ip['floating_ip_address']])
print('Application will be deployed to http://%s' % unused_floating_ip['floating_ip_address'])

Perhatikan bahwa saat ini, saat Anda membuat grup keamanan, Anda menyertakan aturan yang hanya berlaku untuk instance yang merupakan bagian dari grup pekerja.

Selanjutnya, mulai instance kedua, yang akan menjadi instance pekerja:

instance_controller_1 = conn.get_server(instance_controller_1['id'])

if conn.get_server_public_ip(instance_controller_1):
    ip_controller = conn.get_server_public_ip(instance_controller_1)
else:
    ip_controller = conn.get_server_private_ip(instance_controller_1)

userdata = '''#!/usr/bin/env bash
curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \
    -i faafo -r worker -e 'http://%(ip_controller)s' -m 'amqp://guest:guest@%(ip_controller)s:5672/'
''' % {'ip_controller': ip_controller}

instance_worker_1 = conn.create_server(wait=True, auto_ip=False,
    name='app-worker-1',
    image=image_id,
    flavor=flavor_id,
    key_name=keypair_name,
    security_groups=[worker_group_name],
    userdata=userdata)

unused_floating_ip = conn.available_floating_ip()

conn.add_ip_list(instance_worker_1, [unused_floating_ip['floating_ip_address']])
print('The worker will be available for SSH at %s' % unused_floating_ip['floating_ip_address'])


Perhatikan bahwa Anda telah menambahkan instance ini ke worker_group, sehingga bisa mengakses controller.

Seperti yang dapat Anda lihat dari parameter yang dilewatkan ke skrip instalasi, Anda mendefinisikan instance ini sebagai instance pekerja. Tapi, Anda juga menyampaikan alamat instance API dan antrean pesan sehingga pekerja dapat mengambil permintaan. Skrip instalasi aplikasi Fractals menerima beberapa parameter.

Parameter Deskripsi Contoh
-e URL endpoint dari layanan API. http://localhost/
-m URL transport dari layanan pesan. amqp://guest:guest@localhost:5672/
-d URL koneksi untuk database (tidak digunakan disini). sqlite:////tmp/sqlite.db

Sekarang jika Anda membuat permintaan untuk fraktal baru, Anda terhubung ke instance pengontrol, app-controller, tapi pekerjaan sebenarnya akan dilakukan oleh instance pekerja yang terpisah - app-worker-1.

Login dengan SSH dan gunakan aplikasi Fractal

Masuk ke instance pekerja, app-worker-1, dengan SSH, gunakan pasangan kunci SSH yang sebelumnya ditambahkan"demokey ". Mulailah dengan mendapatkan alamat IP pekerja:

instance_worker_1 = conn.get_server(instance_worker_1['name'])
ip_instance_worker_1 = conn.get_server_public_ip(instance_worker_1)
print(ip_instance_worker_1)

Sekarang Anda bisa SSH ke instance:

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

Catatan

Menggantikan IP_WORKER_1 Dengan alamat IP dari instance pekerja dan USERNAME ke nama pengguna yang sesuai.

Setelah Anda masuk (logged in), periksa untuk melihat apakah proses layanan pekerja berjalan seperti yang diharapkan. Anda dapat menemukan log dari layanan pekerja di direktori /var/log/supervisor/.

worker # ps ax | grep faafo-worker
17210 ?        R      7:09 /usr/bin/python /usr/local/bin/faafo-worker

Buka top untuk memantau penggunaan CPU dari proses faafo-worker.

Sekarang masuk ke instance controller, app-controller, juga dengan SSH, gunakan pasangan kunci SSH yang sebelumnya ditambahkan"demokey ".

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

Catatan

Ganti IP_CONTROLLER dengan alamat IP dari instance controller dan USERNAME ke nama pengguna yang sesuai.

Periksa untuk melihat apakah proses layanan API berjalan seperti yang diharapkan. Anda dapat menemukan log untuk layanan API di direktori /var/log/supervisor/.

controller # ps ax | grep faafo-api
17209 ?        Sl     0:19 /usr/bin/python /usr/local/bin/faafo-api

Sekarang panggil antarmuka command line aplikasi Fraktal (faafo) untuk meminta beberapa fraktal baru. Perintah berikut meminta beberapa fraktal dengan parameter acak:

controller # faafo --endpoint-url http://localhost --verbose create
2015-04-02 03:55:02.708 19029 INFO faafo.client [-] generating 6 task(s)

Perhatikan top pada instance pekerja. Tepat setelah menelepon faafo, proses faafo-worker harus mulai menghabiskan banyak siklus CPU.

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
17210 root      20   0  157216  39312   5716 R 98.8  3.9  12:02.15 faafo-worker

Untuk menunjukkan rincian fraktal spesifik gunakan subcommand show dari Faafo CLI.

controller # faafo show 154c7b41-108e-4696-a059-1bde9bf03d0a
+------------+------------------------------------------------------------------+
| Parameter  | Value                                                            |
+------------+------------------------------------------------------------------+
| uuid       | 154c7b41-108e-4696-a059-1bde9bf03d0a                             |
| duration   | 4.163147 seconds                                                 |
| dimensions | 649 x 869 pixels                                                 |
| iterations | 362                                                              |
| xa         | -1.77488588389                                                   |
| xb         | 3.08249829401                                                    |
| ya         | -1.31213919301                                                   |
| yb         | 1.95281690897                                                    |
| size       | 71585 bytes                                                      |
| checksum   | 103c056f709b86f5487a24dd977d3ab88fe093791f4f6b6d1c8924d122031902 |
+------------+------------------------------------------------------------------+

Ada lebih banyak perintah yang tersedia; cari tahu lebih banyak tentang mereka faafo get --help, faafo list --help, dan faafo delete --help.

Catatan

Aplikasi menyimpan image fraktal yang dihasilkan secara langsung di database yang digunakan oleh instance layanan API. Penyimpanan file image dalam database bukanlah praktik yang baik. Kami melakukannya di sini sebagai contoh hanya sebagai cara mudah untuk mengaktifkan beberapa instance agar memiliki akses ke data. Untuk praktik terbaik, kami merekomendasikan menyimpan objek di Object Storage, yang tercakup dalam Make it durable.

Langkah selanjutnya

Anda sekarang harus memiliki pemahaman dasar tentang arsitektur aplikasi berbasis cloud. Selain itu, Anda sudah berlatih memulai instance baru, secara otomatis mengonfigurasikannya saat boot, dan bahkan memodulasi sebuah aplikasi sehingga Anda dapat menggunakan beberapa instance untuk menjalankannya. Ini adalah langkah dasar untuk meminta dan menggunakan sumber daya untuk menjalankan aplikasi Anda di awan OpenStack.

Dari sini, buka Scaling out untuk mempelajari cara meningkatkan skala aplikasi Anda. Atau, cobalah salah satu langkah berikut dalam tutorialnya:

Sampel kode lengkap

File berikut berisi semua kode dari bagian tutorial ini. Sampel kode komprehensif ini memungkinkan Anda melihat dan menjalankan kode sebagai satu skrip.

Sebelum menjalankan skrip ini, konfirmasikan bahwa Anda telah menyetel informasi autentikasi, flavor ID, dan image ID.

# step-1
userdata = '''#!/usr/bin/env bash

curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \
-i faafo -i messaging -r api -r worker -r demo
'''

instance_name = 'all-in-one'
testing_instance = conn.create_server(wait=True, auto_ip=False,
    name=instance_name,
    image=image_id,
    flavor=flavor_id,
    key_name=keypair_name,
    security_groups=[sec_group_name],
    userdata=userdata)

# step-2
userdata = '''#!/usr/bin/env bash

curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \
-i faafo -i messaging -r api -r worker -r demo
'''

# step-3
sec_group_name = 'all-in-one'
conn.create_security_group(sec_group_name, 'network access for all-in-one application.')
conn.create_security_group_rule(sec_group_name, 80, 80, 'TCP')
conn.create_security_group_rule(sec_group_name, 22, 22, 'TCP')

# step-4
sec_groups = conn.list_security_groups()
for sec_group in sec_groups:
    print(sec_group)

# step-5
conn.delete_security_group_rule(rule_id)
conn.delete_security_group(sec_group_name)

# step-6
conn.get_openstack_vars(testing_instance)['security_groups']

# step-7
unused_floating_ip = conn.available_floating_ip()

# step-8
# step-9

# step-10
conn.add_ip_list(testing_instance, [unused_floating_ip['floating_ip_address']])

# step-11
worker_group_name = 'worker'
if conn.search_security_groups(worker_group_name):
    print('Security group \'%s\' already exists. Skipping creation.' % worker_group_name)
else:
    worker_group = conn.create_security_group(worker_group_name, 'for services that run on a worker node')
    conn.create_security_group_rule(worker_group['name'], 22, 22, 'TCP')

controller_group_name = 'control'
if conn.search_security_groups(controller_group_name):
    print('Security group \'%s\' already exists. Skipping creation.' % controller_group_name)
else:
    controller_group = conn.create_security_group(controller_group_name, 'for services that run on a control node')
    conn.create_security_group_rule(controller_group['name'], 22, 22, 'TCP')
    conn.create_security_group_rule(controller_group['name'], 80, 80, 'TCP')
    conn.create_security_group_rule(controller_group['name'], 5672, 5672, 'TCP', remote_group_id=worker_group['id'])

userdata = '''#!/usr/bin/env bash
curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \
    -i messaging -i faafo -r api
'''

instance_controller_1 = conn.create_server(wait=True, auto_ip=False,
    name='app-controller',
    image=image_id,
    flavor=flavor_id,
    key_name=keypair_name,
    security_groups=[controller_group_name],
    userdata=userdata)

unused_floating_ip = conn.available_floating_ip()

conn.add_ip_list(instance_controller_1, [unused_floating_ip['floating_ip_address']])
print('Application will be deployed to http://%s' % unused_floating_ip['floating_ip_address'])

# step-12
instance_controller_1 = conn.get_server(instance_controller_1['id'])

if conn.get_server_public_ip(instance_controller_1):
    ip_controller = conn.get_server_public_ip(instance_controller_1)
else:
    ip_controller = conn.get_server_private_ip(instance_controller_1)

userdata = '''#!/usr/bin/env bash
curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \
    -i faafo -r worker -e 'http://%(ip_controller)s' -m 'amqp://guest:guest@%(ip_controller)s:5672/'
''' % {'ip_controller': ip_controller}

instance_worker_1 = conn.create_server(wait=True, auto_ip=False,
    name='app-worker-1',
    image=image_id,
    flavor=flavor_id,
    key_name=keypair_name,
    security_groups=[worker_group_name],
    userdata=userdata)

unused_floating_ip = conn.available_floating_ip()

conn.add_ip_list(instance_worker_1, [unused_floating_ip['floating_ip_address']])
print('The worker will be available for SSH at %s' % unused_floating_ip['floating_ip_address'])


# step-13
instance_worker_1 = conn.get_server(instance_worker_1['name'])
ip_instance_worker_1 = conn.get_server_public_ip(instance_worker_1)
print(ip_instance_worker_1)
Creative Commons Attribution 3.0 License

Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.