Apa itu Integrasi Berterusan (CI)?

Continuous Integration adalah langkah logik seterusnya setelah mempunyai sistem kawalan versi seperti Git dan sistem kawalan versi jauh seperti GitLab atau GitHub untuk usaha kolaboratif. Masalah yang dihadapi oleh projek besar adalah - Apabila permintaan tarikan baru datang, mereka perlu diuji dan kemudian disatukan ke cabang induk dan usaha ini dapat dilakukan dengan mudah dari beberapa jam hingga beberapa minggu bergantung pada ukuran projek, lokasi ahli pasukan, dll.

Seperti masalah seperti itu, langkah logiknya adalah mengotomatisasi keseluruhan ujian yang tidak betul. Kami melakukannya dengan menyiapkan pencetus sehingga setiap kali komitmen baru digabungkan menjadi cabang ejen (GitLab Runner, misalnya) secara automatik membina persekitaran dan kod, menjalankan semua ujian unit dan ujian integrasi terhadapnya. Sekiranya terdapat ralat yang berlaku maka ia memberi amaran dan laporan kemalangan jika tidak, anda mendapat isyarat hijau yang mengatakan semuanya berfungsi.

Sudah tentu, jika anda berada di tahap yang logik, anda juga boleh mengautomasikan penggunaannya, menyiapkan ujian A / B automatik dan secara keseluruhan membuang campur tangan manusia dari proses tersebut. Itu disebut sebagai Penghantaran Berterusan dan / atau Penerapan Berterusan bergantung pada tahap automasi. Tetapi kami hanya akan fokus pada Integrasi Berterusan dalam tutorial ini.

Prasyarat

Kami akan memberi tumpuan untuk mengatur aliran CI sederhana dalam tutorial menggunakan instance GitLab melalui HTTPS yang telah kami bahas dalam posting sebelumnya.

Selain itu, kami juga menganggap anda telah menyediakan akaun pengguna dalam contoh GitLab ini dan telah sebuah repositori (diklon pada mesin tempatan anda) diuruskan di bawah nama pengguna anda. Ini adalah repositori yang akan kita gunakan untuk menunjukkan aliran kerja CI. Dalam tutorial, namanya akan menjadi projek saya.

Untuk menyenaraikan semuanya:

1. Contoh GitLab
2. Repositori kosong, dipanggil projek saya
3. Klon tempatan repositori ini
4. Instance Git tempatan anda dikonfigurasi untuk mendorong perubahan jauh.

Membuat aplikasi Mudah

Di repositori ini, mari buat Node ringkas.aplikasi js. Aplikasi ini adalah Express ringkas.pelayan js yang dimaksudkan untuk digunakan dalam wadah Docker. Pelayan memberikan muatan HTTP yang mengatakan "Hello World" di penyemak imbas anda.

Di akar repositori tempatan anda, buat fail aplikasi.js dan tambahkan baris berikut:

'gunakan ketat';
const express = memerlukan ('express');
// Pemalar
const PORT = 8080;
const HOST = '0.0.0.0 ';
// Aplikasi
aplikasi const = express ();
aplikasi.dapatkan ('/', (req, res) =>
res.hantar ('Hello world \ n');
);
aplikasi.dengar (PORT, HOST);
konsol.log ('Berjalan di http: // $ HOST: $ PORT');

Kemudian buat fail lain pakej.json dan tambahkan yang berikut:

"nama": "docker_web_app",
"versi": "1.0.0 ",
"description": "Node.js di Docker ",
"pengarang": "John Doe",
pelayan "utama": ".js ",
"skrip":
pelayan nod "start": ".js "
,
"kebergantungan":
"express": "^ 4.16.1 "

Akhir sekali, buat a Dockerfile dan tambahkan kandungan berikut kepadanya:

DARI nod: 8
# Buat direktori aplikasi
WORKDIR / usr / src / aplikasi
# Pasang kebergantungan aplikasi
# Wildcard digunakan untuk memastikan kedua-dua bungkusan.json DAN kunci pakej.json disalin
Pakej COPY *.json ./
Jalankan pemasangan npm
# Sekiranya anda membina kod anda untuk pengeluaran
# RUN npm install --only = produksi
# Sumber aplikasi bundle
SALINAN…
PENDEDAHAN 8080
CMD ["node", "aplikasi"]

Proses membina aplikasi ini akan melibatkan pembuatan bekas nod dan memasang pergantungan (seperti Express.modul js). Proses ini harus berlaku tanpa kesilapan. Demi kesederhanaan, kami tidak akan membincangkan sebarang ujian dalam tutorial ini.

Paip Pelari GitLab

Sekarang kita akan menambah fail lain ke repositori kita yang akan dipanggil .gitlab-ci.yml . Fail ini akan mengandungi arahan untuk membina projek kami. Sekarang, setiap kali kita memberikan komitmen pada contoh GitLab kita, GitLab akan memanggil Runner untuk membina dan menguji projek.

Kami menetapkan pelbagai saluran ini pekerjaan yang dapat dijalankan semua dijalankan secara bebas antara satu sama lain, menjadikan proses binaan lebih fleksibel. Untuk repo di atas, ini adalah sah .gitlab-ci.yml buat fail ini di root repositori anda:

gambar: simpul: terkini
peringkat:
- membina
cache:
jalan:
- simpul_modul /
install_dependencies:
tahap: membina
skrip:
- pasang npm

Kami hanya mempunyai satu tahap membina dan ia hanya pasang npm sebagai skrip. Ini adalah arahan yang harus anda jalankan secara manual setiap kali ada perubahan pada projek anda. Pelari GitLab akan melakukan ini untuk anda. Runner boleh dipasang di kluster Kubernetes, VPS di awan atau di stesen kerja tempatan anda dan jika ia aktif, ia akan menunggu arahan dari pelayan GitLab untuk melaksanakan binaan.

Kami akan memasang dan mengkonfigurasi Runner secara tempatan untuk mengautomasikannya.

Mendapatkan Token Pelari

Buka repositori anda di GitLab, dan kunjungi tetapan CD / CInya. Itu Tetapan → CD / CI di dalam repositori ujian anda.

Biarkan tetapan Auto DevOps ke lalai dan klik KELUARKAN untuk meluaskan tetapan Paip Umum dan anda akan ditunjukkan Runner Token. Salin nilainya dan, tentu saja, rahsia jika anda menghargai projek anda.

Dengan menggunakan token ini, pelaksana GitLab Runner tempatan anda akan dapat mendaftar dengan selamat dengan instance GitLab anda.

Memasang GitLab Runner

Pelari GitLab adalah program ringan kecil yang ditulis dalam Go yang menjalankan CI yang berkaitan pekerjaan pada mesin tempatan anda dan menghantar hasilnya ke GitLab untuk mempertimbangkan perubahannya. Ini adalah satu binari yang boleh dilaksanakan yang boleh dipasang pada mana-mana OS utama. Ikuti arahan di sini, untuk Sistem Operasi tertentu anda. Pemasangan ini berbeza-beza sehingga menyenaraikan semuanya tidak dapat dilaksanakan.

Sebagai alternatif anda boleh menggunakan Runner sebagai perkhidmatan Docker, tetapi mari kita berpegang pada pemasangan tradisional, kerana perintahnya lebih mudah dibaca dan difahami bagi pembaca. Setelah memasangnya di stesen kerja tempatan anda, anda perlu melaksanakan perintah:

daftar $ gitlab-runner

Ini akan menanyakan beberapa soalan bermula dengan koordinator GitLab-CI anda yang akan menjadi contoh GitLab anda:

daftar $ gitlab-runner
Sila masukkan URL penyelaras gitlab-ci (e.g. https: // gitlab.com /):
https: // gitlab.contoh.com

Ia kemudian akan meminta Runner Token anda, yang kami perolehi di bahagian sebelumnya:

Sila masukkan token gitlab-ci untuk pelari ini:

Tanda_Secret Anda

Kemudian untuk beberapa keterangan yang boleh dikenal pasti dan anda boleh melangkau menambah tag dengan menekan :

Sila masukkan keterangan gitlab-ci untuk pelari ini:

[Hostname]: Demo untuk menyiapkan CI menggunakan Runner

Sila masukkan tag gitlab-ci untuk pelari ini (dipisahkan dengan koma):

Mendaftar pelari… berjaya

Yang paling penting, ia akan meminta anda pelaksana (lebih lanjut mengenai ini sebentar lagi), kami akan memilih Docker demi contoh kami.

Sila masukkan pelaksana: mesin docker-ssh +, kubernetes, paralel, shell, ssh, virtualbox, docker + machine, docker, docker-ssh:

tukang dok

Gambar Base docker di mana binaan akan berlaku kemudian perlu ditentukan, aplikasi sampel kami menggunakan nod jadi kami akan menentukan gambar nod:

Sila masukkan gambar Docker lalai (e.g. rubi: 2.1):

simpul: terkini

Pelari berjaya mendaftar. Jangan ragu untuk memulakannya, tetapi jika sudah berjalan, konfigurasi harus dimuat semula secara automatik!

Sekarang sesuatu yang memerlukan sedikit penjelasan di sini adalah apa sebenarnya pelaksana? Cara aliran kerja CI adalah bahawa pembinaan modul, pengujiannya, dan lain-lain dikenali sebagai pekerjaan dan pelaksana melaksanakan pekerjaan tersebut. Sekiranya anda memilih VirtualBox sebagai pelaksana, maka pelari GitLab akan berintegrasi dengan VirtualBox yang dipasang secara tempatan dan menjalankan pekerjaan CI dalam VM, jika anda memilih kubernetes maka itu akan berlaku di kluster Kubernetes anda, di awan, jika anda memilih ssh anda boleh mewakilkan tugas CI ke pelayan jauh.

Contoh projek kami berdasarkan Docker, jadi masuk akal untuk menggunakan Docker sebagai pelaksana kami. Anda perlu ada Docker dipasang secara tempatan untuk ini.

Mempunyai pelbagai pilihan untuk pelaksana menjadikan Runner lebih fleksibel. Anda mungkin mahu membina secara tempatan kerana fail projek terlalu besar atau anda mungkin mahu melaksanakannya dalam pelayan jauh dengan 20 teras dan setengah terabyte RAM kerana proses pembuatannya sangat intensif, menentukan pilihan pelaksana memberikan anda fleksibiliti.

Terakhir, di cengkerang anda ingin memulakan perkhidmatan Runner:

permulaan $ gitlab-runner

Melihat .gitlab-ci.yml beraksi

Sekarang kami telah membuat semua perubahan ini di repo tempatan kami membuat semua aplikasi.js, pakej.json, Dockerfile dan .gitlab-ci.fail yml. Agaknya, anda melakukan perubahan pada repositori tempatan anda dengan menjalankan:

$ git tahap nama_nama
$ git commit -m "Komit Mesej"

Mari tekan perubahan ke GitLab jauh kami.

$ git push -u asal

Anda kemudian boleh membuka projek anda di GitLab, pergi ke my-projek → Saluran paip dan anda akan melihat tanda ini yang bertuliskan "lulus" di sebelah komit yang anda buat. Komitmen berikutnya, juga akan mempunyai tag.

Jadi itulah asas CI menggunakan GitLab dan Runner. Semoga anda menikmati siaran dan belajar sesuatu yang baru daripadanya.