Clever Geek Handbook

Kami menerima 10.000 acara di Yandex.Cloud. Bagian 1

Halo semuanya, teman!



* Artikel ini ditulis berdasarkan lokakarya terbuka REBRAIN & Yandex.Cloud, jika Anda suka menonton videonya, Anda dapat menemukannya di tautan ini - https://youtu.be/cZLezUm0ekE



Baru-baru ini kami berkesempatan untuk menyentuh Yandex.Cloud secara langsung. Berhubung kami ingin merasakannya dalam waktu yang lama dan erat, kami langsung meninggalkan ide untuk meluncurkan blog wordpress sederhana dengan cloud base - terlalu membosankan. Setelah beberapa pertimbangan, kami memutuskan untuk menerapkan sesuatu yang mirip dengan arsitektur produksi layanan untuk menerima dan menganalisis peristiwa dalam mode waktu nyata.



Saya sangat yakin bahwa sebagian besar bisnis online (dan tidak hanya) dengan satu atau lain cara mengumpulkan segunung informasi tentang pengguna dan tindakan mereka. Minimal, ini diperlukan untuk membuat keputusan tertentu - misalnya, jika Anda mengelola sebuah game online - Anda dapat melihat statistik pada level mana pengguna yang paling mungkin terjebak dan menghapus mainan Anda. Atau mengapa pengguna meninggalkan situs Anda tanpa membeli apa pun (halo, Yandex.Metrica).



Jadi, cerita kami: bagaimana kami menulis aplikasi di golang, menguji kafka vs rabbitmq vs yqs, menulis streaming data ke cluster Clickhouse, dan memvisualisasikan data menggunakan yandex datalens. Tentu semua itu dibumbui dengan kelezatan infrastruktur berupa buruh pelabuhan, terraform, gitlab ci, dan tentu saja prometheus. Ayo pergi!



Saya ingin segera membuat reservasi bahwa kami tidak akan dapat mengonfigurasi semuanya dalam satu kesempatan - untuk ini kami memerlukan beberapa artikel dalam rangkaian. Sedikit tentang struktur:



Bagian 1 (Anda sedang membacanya). Kami akan menentukan spesifikasi teknis dan arsitektur solusi, dan juga menulis aplikasi di golang.

Bagian 2. Kami merilis aplikasi kami ke produksi, membuatnya dapat diskalakan dan menguji beban.

Bagian 3. Mari kita coba mencari tahu mengapa kita perlu menyimpan pesan dalam buffer, dan bukan dalam file, dan juga membandingkan layanan antrian kafka, rabbitmq, dan yandex.

Bagian 4. Kami akan menerapkan cluster Clickhouse, menulis streaming untuk mentransfer data dari buffer di sana, menyiapkan visualisasi di datalens.

Bagian 5. Mari kita letakkan seluruh infrastruktur dalam bentuk yang tepat - konfigurasikan ci / cd menggunakan gitlab ci, hubungkan pemantauan dan penemuan layanan menggunakan prometheus dan konsul.



TK



Pertama, kita akan merumuskan kerangka acuan - apa sebenarnya yang ingin kita dapatkan pada keluarannya.



  1. Kami ingin memiliki titik akhir dari bentuk events.kis.im (kis.im adalah domain uji yang akan kami gunakan di semua artikel), yang harus menerima acara menggunakan HTTPS.
  2. Acara adalah json sederhana dalam bentuk: {"event": "view", "os": "linux", "browser": "chrome"}. Pada tahap akhir, kami akan menambahkan lebih banyak bidang, tetapi ini tidak akan memainkan peran besar. Jika mau, Anda dapat beralih ke protobuf.
  3. Layanan tersebut harus dapat memproses 10.000 peristiwa per detik.
  4. Ini harus dapat menskalakan secara horizontal hanya dengan menambahkan contoh baru ke solusi kami. Dan alangkah baiknya jika kita dapat memindahkan front-end ke lokasi geografis yang berbeda untuk mengurangi latensi untuk permintaan klien.
  5. Toleransi kesalahan. Solusinya harus cukup stabil dan mampu bertahan ketika ada bagian yang jatuh (hingga jumlah tertentu, tentunya).


Arsitektur



Secara umum, untuk jenis tugas ini, arsitektur klasik telah lama ditemukan yang memungkinkan Anda melakukan penskalaan secara efektif. Gambar tersebut menunjukkan contoh solusi kami.







Jadi, apa yang kita miliki:



1. Di sebelah kiri ditampilkan perangkat kita yang menghasilkan berbagai peristiwa, baik itu melewati level pemain dalam mainan di smartphone atau membuat pesanan di toko online melalui browser biasa. Acara, seperti yang ditunjukkan dalam TOR, adalah json sederhana yang dikirim ke titik akhir kami - events.kis.im.



2. Dua server pertama adalah penyeimbang sederhana, tugas utamanya adalah:



  • . , , keepalived, IP .
  • TLS. , TLS . -, , -, , backend .
  • backend . — . , , load balancer’ .


3. Di belakang penyeimbang, kami memiliki server aplikasi yang menjalankan aplikasi yang cukup sederhana. Itu harus dapat menerima permintaan HTTP yang masuk, memvalidasi json yang dikirim dan menyimpan data ke dalam buffer.



4. Diagram menunjukkan kafka sebagai penyangga, meskipun, tentu saja, layanan serupa lainnya dapat digunakan pada tingkat ini. Kami akan membandingkan Kafka, rabbitmq, dan yqs di artikel ketiga.



5. Titik terakhir dari arsitektur kami adalah Clickhouse - database kolom yang memungkinkan Anda menyimpan dan memproses data dalam jumlah besar. Pada tingkat ini, kita perlu mentransfer data dari buffer ke, sebenarnya, sistem penyimpanan (tentang ini - dalam artikel 4).



Pengaturan ini memungkinkan kita untuk menskalakan setiap lapisan secara horizontal. Server backend tidak dapat mengatasi - mari tambahkan lebih banyak - karena ini adalah aplikasi tanpa status, dan oleh karena itu, ini dapat dilakukan bahkan dalam mode otomatis. Itu tidak menarik buffer dalam bentuk kafka - kami akan menambahkan lebih banyak server dan mentransfer beberapa partisi dari topik kami kepada mereka. Rumah klik gagal - tidak mungkin :) Faktanya, kami juga akan menghentikan server dan membagikan data.



Ngomong-ngomong, jika Anda ingin menerapkan bagian opsional dari spesifikasi teknis kami dan melakukan penskalaan di lokasi geografis yang berbeda, tidak ada yang lebih mudah:







Di setiap geolokasi, kami menerapkan penyeimbang beban dengan aplikasi dan kafka. Secara umum, 2 server aplikasi, 3 node kafka dan penyeimbang cloud, misalnya cloudflare, sudah cukup, yang akan memeriksa ketersediaan node aplikasi dan menyeimbangkan permintaan berdasarkan geolokasi berdasarkan alamat IP asli klien. Dengan demikian, data yang dikirim oleh klien Amerika akan mendarat di server Amerika. Dan data dari Afrika - di Afrika.



Maka semuanya cukup sederhana - kami menggunakan alat cermin dari kumpulan kafka dan menyalin semua data dari semua lokasi ke pusat data kami yang berlokasi di Rusia. Di dalamnya, kami mengurai data dan menuliskannya ke Clickhouse untuk visualisasi selanjutnya.



Jadi, kami menemukan arsitekturnya - mari mulai mengguncang Yandex.Cloud!



Menulis aplikasi



Sebelum Cloud, Anda masih harus bersabar sedikit dan menulis layanan yang cukup sederhana untuk memproses peristiwa yang masuk. Kami akan menggunakan golang, karena telah terbukti dengan sangat baik sebagai bahasa untuk menulis aplikasi jaringan.



Setelah menghabiskan satu jam (mungkin beberapa jam), kami mendapatkan sesuatu seperti ini: https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/main.go .



Apa poin utama di sini yang ingin saya catat:



1. Saat memulai aplikasi, Anda dapat menentukan dua flag. Satu bertanggung jawab atas port tempat kita akan mendengarkan permintaan http masuk (-addr). Yang kedua adalah untuk alamat server kafka tempat kami akan merekam acara kami (-kafka): 



addr     = flag.String("addr", ":8080", "TCP address to listen to")
kafka    = flag.String("kafka", "127.0.0.1:9092", "Kafka endpoints”)


2. Aplikasi menggunakan pustaka sarama ( [] github.com/Shopify/sarama ) untuk mengirim pesan ke klaster kafka. Kami segera mengatur pengaturan yang difokuskan pada kecepatan pemrosesan maksimum: 



config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForLocal
config.Producer.Compression = sarama.CompressionSnappy
config.Producer.Return.Successes = true


3. Selain itu, aplikasi kami memiliki klien prometheus bawaan yang mengumpulkan berbagai metrik, seperti:



  • jumlah permintaan ke aplikasi kita;
  • jumlah kesalahan saat menjalankan permintaan (tidak mungkin membaca permintaan posting, json rusak, tidak mungkin menulis ke kafka);
  • waktu pemrosesan satu permintaan dari klien, termasuk saat menulis pesan ke kafka.


4. Tiga titik akhir yang diproses aplikasi kita:



  • / status - kembalikan ok untuk menunjukkan kita masih hidup. Meskipun Anda dapat menambahkan beberapa pemeriksaan, seperti ketersediaan cluster Kafka.
  • / metrik - menurut url ini, klien prometheus akan mengembalikan metrik yang telah dikumpulkannya.
  • /post — endpoint, POST json . json — -.


Saya akan membuat reservasi bahwa kodenya tidak sempurna - dapat (dan seharusnya!) Selesai. Misalnya, Anda dapat berhenti menggunakan built-in net / http dan beralih ke fasthttp yang lebih cepat. Atau Anda bisa mendapatkan waktu pemrosesan dan sumber daya cpu dengan melakukan pemeriksaan validasi json ke tahap selanjutnya - saat data akan ditransfer dari buffer ke cluster clickhouse.



Selain sisi pengembangan masalah, kami segera memikirkan infrastruktur masa depan kami dan memutuskan untuk menerapkan aplikasi kami melalui buruh pelabuhan. Dockerfile terakhir untuk membangun aplikasi adalah https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/Dockerfile . Secara umum, ini cukup sederhana, satu-satunya hal yang ingin saya perhatikan adalah perakitan multistage, yang memungkinkan kita mengurangi gambar akhir wadah kita.



Langkah pertama di cloud



Pertama-tama, kami mendaftar di cloud.yandex.ru . Setelah mengisi semua bidang wajib, kami akan membuat akun dan memberikan hibah sejumlah uang yang dapat digunakan untuk menguji layanan cloud. Jika Anda ingin mengulangi semua langkah dari artikel kami, hibah ini seharusnya cukup untuk Anda.



Setelah pendaftaran, awan terpisah dan direktori default akan dibuat untuk Anda, di mana Anda dapat mulai membuat sumber daya awan. Secara umum, di Yandex.Cloud, hubungan antar sumber daya adalah sebagai berikut:







Anda dapat membuat beberapa cloud untuk satu akun. Dan di dalam cloud, buat direktori yang berbeda untuk berbagai proyek perusahaan. Anda dapat membaca lebih lanjut tentang ini di dokumentasi - https://cloud.yandex.ru/docs/resource-manager/concepts/resources-hierarchy... Ngomong-ngomong, di bawah teks ini saya akan sering merujuknya. Ketika saya mengatur seluruh infrastruktur dari awal, dokumentasi membantu saya lebih dari sekali, jadi saya menyarankan Anda untuk belajar.



Untuk mengelola cloud, Anda dapat menggunakan antarmuka web dan utilitas konsol - yc. Instalasi dilakukan dengan satu perintah (untuk Linux dan Mac Os): 



curl https://storage.yandexcloud.net/yandexcloud-yc/install.sh | bash


Jika penjaga keamanan internal mengamuk tentang menjalankan skrip dari Internet, maka, pertama, Anda dapat membuka skrip dan membacanya, dan kedua, kami menjalankannya di bawah pengguna kami - tanpa hak root.



Jika Anda ingin menginstal klien untuk windows, maka Anda dapat menggunakan petunjuk di sini dan kemudian ikuti yc inituntuk mengkonfigurasinya sepenuhnya: 



vozerov@mba:~ $ yc init
Welcome! This command will take you through the configuration process.
Please go to https://oauth.yandex.ru/authorize?response_type=token&client_id= in order to obtain OAuth token.

Please enter OAuth token:
Please select cloud to use:
 [1] cloud-b1gv67ihgfu3bp (id = b1gv67ihgfu3bpt24o0q)
 [2] fevlake-cloud (id = b1g6bvup3toribomnh30)
Please enter your numeric choice: 2
Your current cloud has been set to 'fevlake-cloud' (id = b1g6bvup3toribomnh30).
Please choose folder to use:
 [1] default (id = b1g5r6h11knotfr8vjp7)
 [2] Create a new folder
Please enter your numeric choice: 1
Your current folder has been set to 'default' (id = b1g5r6h11knotfr8vjp7).
Do you want to configure a default Compute zone? [Y/n]
Which zone do you want to use as a profile default?
 [1] ru-central1-a
 [2] ru-central1-b
 [3] ru-central1-c
 [4] Don't set default zone
Please enter your numeric choice: 1
Your profile default Compute zone has been set to 'ru-central1-a'.
vozerov@mba:~ $


Pada prinsipnya, prosesnya sederhana - pertama Anda perlu mendapatkan token oauth untuk manajemen cloud, pilih cloud dan folder yang akan Anda gunakan.



Jika Anda memiliki beberapa akun atau folder dalam cloud yang sama, Anda dapat membuat profil tambahan dengan pengaturan terpisah melalui yc config profile create dan beralih di antaranya.



Selain metode di atas, tim Yandex.Cloud telah menulis plugin terraform yang sangat bagus untuk mengelola sumber daya cloud. Untuk bagian saya, saya menyiapkan repositori git, tempat saya menjelaskan semua sumber daya yang akan dibuat dalam kerangka artikel - https://github.com/rebrainme/yandex-cloud-events/ . Kami tertarik dengan cabang master, mari kita klon secara lokal: 




vozerov@mba:~ $ git clone https://github.com/rebrainme/yandex-cloud-events/ events
Cloning into 'events'...
remote: Enumerating objects: 100, done.
remote: Counting objects: 100% (100/100), done.
remote: Compressing objects: 100% (68/68), done.
remote: Total 100 (delta 37), reused 89 (delta 26), pack-reused 0
Receiving objects: 100% (100/100), 25.65 KiB | 168.00 KiB/s, done.
Resolving deltas: 100% (37/37), done.
vozerov@mba:~ $ cd events/terraform/


Semua variabel utama yang digunakan di terraform ditulis di file main.tf. Untuk memulai, buat file private.auto.tfvars di folder terraform dengan konten berikut: 



# Yandex Cloud Oauth token
yc_token = ""
# Yandex Cloud ID
yc_cloud_id = ""
# Yandex Cloud folder ID
yc_folder_id = ""
# Default Yandex Cloud Region
yc_region = "ru-central1-a"
# Cloudflare email
cf_email = ""
# Cloudflare token
cf_token = ""
# Cloudflare zone id
cf_zone_id = ""


Semua variabel dapat diambil dari daftar konfigurasi yc, karena kita telah mengkonfigurasi utilitas konsol. Saya menyarankan Anda untuk segera menambahkan private.auto.tfvars ke .gitignore agar tidak mempublikasikan data pribadi secara tidak sengaja.



Di private.auto.tfvars, kami juga menentukan data dari Cloudflare - untuk membuat catatan dns dan membuat proxy domain events.kis.im utama ke server kami. Jika Anda tidak ingin menggunakan cloudflare, hapus inisialisasi penyedia cloudflare di main.tf dan file dns.tf, yang bertanggung jawab untuk membuat catatan dns yang diperlukan.



Dalam pekerjaan kami, kami akan menggabungkan ketiga metode - antarmuka web, utilitas konsol, dan terraform.



Jaringan virtual



Sejujurnya, langkah ini dapat dilewati, karena ketika Anda membuat cloud baru, Anda secara otomatis akan memiliki jaringan terpisah dan 3 subnet - satu untuk setiap Availability Zone. Namun, saya ingin membuat jaringan terpisah untuk proyek kami dengan pengalamatannya sendiri. Skema umum operasi jaringan di Yandex.Cloud ditunjukkan pada gambar di bawah ini (secara jujur ​​diambil dari https://cloud.yandex.ru/docs/vpc/concepts/ )







Jadi, Anda membuat jaringan umum di mana sumber daya dapat berkomunikasi satu sama lain. Untuk setiap zona ketersediaan, subnet dibuat dengan pengalamatannya sendiri dan terhubung ke jaringan publik. Alhasil, semua resource cloud di dalamnya bisa berkomunikasi, meski berada di availability zone yang berbeda. Sumber daya yang terhubung ke jaringan cloud yang berbeda hanya dapat melihat satu sama lain melalui alamat eksternal. Ngomong-ngomong, cara kerja sihir ini di dalam dijelaskan dengan baik di Habré .



Pembuatan jaringan dijelaskan dalam file network.tf dari repositori. Di sana kami membuat satu jaringan pribadi umum internal dan menghubungkannya tiga subnet di zona ketersediaan yang berbeda - internal-a (172.16.1.0/24), internal-b (172.16.2.0/24), internal-c (172.16.3.0/24 ).



Kami menginisialisasi terraform dan membuat jaringan: 



vozerov@mba:~/events/terraform (master) $ terraform init
... skipped ..

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_vpc_subnet.internal-a -target yandex_vpc_subnet.internal-b -target yandex_vpc_subnet.internal-c

... skipped ...

Plan: 4 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

yandex_vpc_network.internal: Creating...
yandex_vpc_network.internal: Creation complete after 3s [id=enp2g2rhile7gbqlbrkr]
yandex_vpc_subnet.internal-a: Creating...
yandex_vpc_subnet.internal-b: Creating...
yandex_vpc_subnet.internal-c: Creating...
yandex_vpc_subnet.internal-a: Creation complete after 6s [id=e9b1dad6mgoj2v4funog]
yandex_vpc_subnet.internal-b: Creation complete after 7s [id=e2liv5i4amu52p64ac9p]
yandex_vpc_subnet.internal-c: Still creating... [10s elapsed]
yandex_vpc_subnet.internal-c: Creation complete after 10s [id=b0c2qhsj2vranoc9vhcq]

Apply complete! Resources: 4 added, 0 changed, 0 destroyed.


Luar biasa! Kami telah membuat jaringan kami dan sekarang siap untuk membuat layanan internal kami.



Membuat mesin virtual



Untuk menguji aplikasi, cukup bagi kita untuk membuat dua mesin virtual - kita memerlukan yang pertama untuk membangun dan menjalankan aplikasi, yang kedua - untuk menjalankan kafka, yang akan kita gunakan untuk menyimpan pesan masuk. Dan kami akan membuat mesin lain, di mana kami akan mengkonfigurasi prometheus untuk memantau aplikasi.



Mesin virtual akan dikonfigurasi menggunakan ansible, jadi pastikan Anda memiliki salah satu versi terbaru yang memungkinkan sebelum memulai terraform. Dan instal peran yang diperlukan dengan galaksi yang memungkinkan: 



vozerov@mba:~/events/terraform (master) $ cd ../ansible/
vozerov@mba:~/events/ansible (master) $ ansible-galaxy install -r requirements.yml
- cloudalchemy-prometheus (master) is already installed, skipping.
- cloudalchemy-grafana (master) is already installed, skipping.
- sansible.kafka (master) is already installed, skipping.
- sansible.zookeeper (master) is already installed, skipping.
- geerlingguy.docker (master) is already installed, skipping.
vozerov@mba:~/events/ansible (master) $


Di dalam folder ansible, ada contoh file config .ansible.cfg yang saya gunakan. Mungkin berguna.



Sebelum membuat mesin virtual, pastikan bahwa Anda telah menjalankan ssh-agent dan kunci ssh ditambahkan, jika tidak terraform tidak akan dapat terhubung ke mesin yang dibuat. Tentu saja saya menemukan bug di os x: https://github.com/ansible/ansible/issues/32499#issuecomment-341578864 . Untuk menghindari pengulangan cerita ini, tambahkan variabel kecil ke env sebelum memulai Terraform: 



vozerov@mba:~/events/terraform (master) $ export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES


Buat sumber daya yang diperlukan di folder terraform: 



vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_compute_instance.build -target yandex_compute_instance.monitoring -target yandex_compute_instance.kafka
yandex_vpc_network.internal: Refreshing state... [id=enp2g2rhile7gbqlbrkr]
data.yandex_compute_image.ubuntu_image: Refreshing state...
yandex_vpc_subnet.internal-a: Refreshing state... [id=e9b1dad6mgoj2v4funog]

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

... skipped ...

Plan: 3 to add, 0 to change, 0 to destroy.

... skipped ...


Jika semuanya berakhir dengan baik (dan seharusnya), maka kita akan memiliki tiga mesin virtual:



  1. build - mesin untuk menguji dan membangun aplikasi. Docker diinstal secara otomatis oleh ansible.
  2. pemantauan - mesin untuk memantau - prometheus & grafana diinstal di atasnya. Login / kata sandi standar: admin / admin
  3. kafka adalah mobil kecil dengan kafka terpasang, tersedia di port 9092.


Mari kita pastikan semuanya ada pada tempatnya: 



vozerov@mba:~/events (master) $ yc compute instance list
+----------------------+------------+---------------+---------+---------------+-------------+
|          ID          |    NAME    |    ZONE ID    | STATUS  |  EXTERNAL IP  | INTERNAL IP |
+----------------------+------------+---------------+---------+---------------+-------------+
| fhm081u8bkbqf1pa5kgj | monitoring | ru-central1-a | RUNNING | 84.201.159.71 | 172.16.1.35 |
| fhmf37k03oobgu9jmd7p | kafka      | ru-central1-a | RUNNING | 84.201.173.41 | 172.16.1.31 |
| fhmt9pl1i8sf7ga6flgp | build      | ru-central1-a | RUNNING | 84.201.132.3  | 172.16.1.26 |
+----------------------+------------+---------------+---------+---------------+-------------+


Sumber daya sudah tersedia, dan dari sini kita dapat menarik alamat ip mereka. Di mana-mana di bawah ini, saya akan menggunakan alamat ip untuk terhubung melalui ssh dan menguji aplikasi. Jika Anda memiliki akun cloudflare yang terhubung ke terraform, silakan gunakan nama DNS yang baru dibuat.

Omong-omong, saat membuat mesin virtual, ip internal dan nama DNS internal dikeluarkan, jadi Anda dapat merujuk ke server di dalam jaringan dengan nama: 



ubuntu@build:~$ ping kafka.ru-central1.internal
PING kafka.ru-central1.internal (172.16.1.31) 56(84) bytes of data.
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=1 ttl=63 time=1.23 ms
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=2 ttl=63 time=0.625 ms
^C
--- kafka.ru-central1.internal ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.625/0.931/1.238/0.308 ms


Ini akan berguna bagi kami untuk menunjukkan ke aplikasi titik akhir dengan kafk.



Menyusun aplikasi



Hebat, ada server, ada aplikasi - yang tersisa hanyalah mengumpulkan dan menerbitkannya. Untuk perakitan, kami akan menggunakan build buruh pelabuhan biasa, tetapi sebagai penyimpanan gambar kami akan mengambil layanan dari Yandex - registri kontainer. Tapi hal pertama yang pertama.



Salin aplikasi ke mesin build, buka ssh dan kumpulkan gambarnya: 



vozerov@mba:~/events/terraform (master) $ cd ..
vozerov@mba:~/events (master) $ rsync -av app/ ubuntu@84.201.132.3:app/

... skipped ...

sent 3849 bytes  received 70 bytes  7838.00 bytes/sec
total size is 3644  speedup is 0.93

vozerov@mba:~/events (master) $ ssh 84.201.132.3 -l ubuntu
ubuntu@build:~$ cd app
ubuntu@build:~/app$ sudo docker build -t app .
Sending build context to Docker daemon  6.144kB
Step 1/9 : FROM golang:latest AS build
... skipped ...

Successfully built 9760afd8ef65
Successfully tagged app:latest


Setengah pertempuran telah selesai - sekarang Anda dapat memeriksa fungsionalitas aplikasi kami dengan menjalankannya dan mengarahkannya ke kafka: 



ubuntu@build:~/app$ sudo docker run --name app -d -p 8080:8080 app /app/app -kafka=kafka.ru-central1.internal:9092</code>

      event    :

<code>vozerov@mba:~/events (master) $ curl -D - -s -X POST -d '{"key1":"data1"}' http://84.201.132.3:8080/post
HTTP/1.1 200 OK
Content-Type: application/json
Date: Mon, 13 Apr 2020 13:53:54 GMT
Content-Length: 41

{"status":"ok","partition":0,"Offset":0}
vozerov@mba:~/events (master) $


Aplikasi merespons dengan keberhasilan perekaman dan menunjukkan id partisi dan offset, tempat pesan tersebut jatuh. Satu-satunya hal yang harus dilakukan adalah membuat registri di Yandex.Cloud dan mengunggah gambar kami di sana (cara melakukan ini menggunakan tiga baris dijelaskan di file registry.tf). Kami membuat repositori: 



vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_container_registry.events

... skipped ...

Plan: 1 to add, 0 to change, 0 to destroy.

... skipped ...

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.


Ada beberapa cara untuk mengautentikasi di registri penampung - menggunakan token oauth, token iam, atau kunci akun layanan. Untuk informasi lebih lanjut tentang metode ini, lihat dokumentasi https://cloud.yandex.ru/docs/container-registry/operations/authentication . Kami akan menggunakan kunci akun layanan, jadi kami membuat akun: 



vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_iam_service_account.docker -target yandex_resourcemanager_folder_iam_binding.puller -target yandex_resourcemanager_folder_iam_binding.pusher

... skipped ...

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.


Sekarang tinggal membuat kunci untuknya: 



vozerov@mba:~/events/terraform (master) $ yc iam key create --service-account-name docker -o key.json
id: ajej8a06kdfbehbrh91p
service_account_id: ajep6d38k895srp9osij
created_at: "2020-04-13T14:00:30Z"
key_algorithm: RSA_2048


Kami mendapatkan informasi tentang id penyimpanan kami, membalik kunci dan masuk: 



vozerov@mba:~/events/terraform (master) $ scp key.json ubuntu@84.201.132.3:
key.json                                                                                                                    100% 2392   215.1KB/s   00:00

vozerov@mba:~/events/terraform (master) $ ssh 84.201.132.3 -l ubuntu

ubuntu@build:~$ cat key.json | sudo docker login --username json_key --password-stdin cr.yandex
WARNING! Your password will be stored unencrypted in /home/ubuntu/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
ubuntu@build:~$


Untuk memuat gambar ke dalam registri, kami memerlukan registri kontainer ID, kami mengambilnya dari utilitas yc: 



vozerov@mba:~ $ yc container registry get events
id: crpdgj6c9umdhgaqjfmm
folder_id:
name: events
status: ACTIVE
created_at: "2020-04-13T13:56:41.914Z"


Setelah itu, kami menandai gambar kami dengan nama baru dan memuat: 



ubuntu@build:~$ sudo docker tag app cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
ubuntu@build:~$ sudo docker push cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
The push refers to repository [cr.yandex/crpdgj6c9umdhgaqjfmm/events]
8c286e154c6e: Pushed
477c318b05cb: Pushed
beee9f30bc1f: Pushed
v1: digest: sha256:1dd5aaa9dbdde2f60d833be0bed1c352724be3ea3158bcac3cdee41d47c5e380 size: 946


Kami dapat memverifikasi bahwa gambar berhasil di-boot: 



vozerov@mba:~/events/terraform (master) $ yc container repository list
+----------------------+-----------------------------+
|          ID          |            NAME             |
+----------------------+-----------------------------+
| crpe8mqtrgmuq07accvn | crpdgj6c9umdhgaqjfmm/events |
+----------------------+-----------------------------+


Omong-omong, jika Anda menginstal utilitas yc di mesin linux, Anda dapat menggunakan perintah 



yc container registry configure-docker


untuk penyiapan buruh pelabuhan.



Kesimpulan



Kami telah melakukan pekerjaan yang hebat dan sulit dan sebagai hasilnya:



  1. .
  2. golang, -.
  3. container registry.


Di bagian selanjutnya, kita akan beralih ke hal-hal menarik - kita akan menuangkan aplikasi kita ke dalam produksi dan akhirnya meluncurkan beban di atasnya. Jangan beralih!



Materi ini ada dalam video lokakarya terbuka REBRAIN & Yandex.Cloud: Kami menerima 10.000 permintaan per detik di Yandex Cloud - https://youtu.be/cZLezUm0ekE





Jika Anda tertarik untuk menghadiri acara semacam itu secara online dan mengajukan pertanyaan secara real time, hubungkan ke saluran DevOps oleh REBRAIN .



Kami ingin mengucapkan terima kasih khusus kepada Yandex.Cloud atas kesempatan untuk mengadakan acara seperti itu. Tautan ke sana adalah https://cloud.yandex.ru/prices



Jika Anda perlu pindah ke cloud atau memiliki pertanyaan tentang infrastruktur Anda, silakan tinggalkan permintaan .



P.S. 2 , , .


More articles:


All Articles