Apa itu Integrasi Berkelanjutan (CI)?

Integrasi Berkelanjutan adalah langkah logis berikutnya setelah memiliki sistem kontrol versi seperti Git dan sistem kontrol versi jarak jauh seperti GitLab atau GitHub untuk upaya kolaboratif. Masalah yang dihadapi proyek besar adalah ini - Saat permintaan tarik baru datang, mereka perlu diuji dan kemudian diintegrasikan ke cabang master dan upaya ini dapat dengan mudah memakan waktu mulai dari beberapa jam hingga beberapa minggu tergantung pada ukuran proyek, lokasi anggota tim, dll.

Seperti masalah semacam itu, langkah logisnya adalah mengotomatiskan seluruh omong kosong pengujian. Kami melakukannya dengan menyiapkan pemicu sehingga setiap kali komit yang lebih baru digabungkan ke dalam cabang, agen (GitLab Runner, misalnya) secara otomatis membangun lingkungan dan kode, menjalankan semua pengujian unit dan pengujian integrasi terhadapnya. Jika ada kesalahan yang ditemui maka itu memberikan peringatan dan laporan kerusakan jika tidak, Anda mendapatkan sinyal hijau yang mengatakan semuanya berfungsi.

Tentu saja, dibawa ke ekstrem logisnya, Anda juga dapat mengotomatiskan penerapan, menyiapkan pengujian A/B otomatis, dan sepenuhnya menghapus campur tangan manusia dari proses. Itu disebut sebagai Pengiriman Berkelanjutan dan/atau Penerapan Berkelanjutan tergantung pada tingkat otomatisasi. Tapi kami hanya akan fokus pada Integrasi Berkelanjutan dalam tutorial ini.

Prasyarat

Kami akan fokus pada pengaturan aliran CI sederhana dalam tutorial menggunakan instance GitLab melalui HTTPS yang telah kami bahas di posting sebelumnya.

Selain itu, kami juga menganggap Anda telah menyiapkan akun pengguna di instance GitLab ini dan telah gudang (dikloning pada mesin lokal Anda) dikelola di bawah nama pengguna Anda. Repositori inilah yang akan kita gunakan untuk mendemonstrasikan alur kerja CI. Dalam tutorial, namanya akan menjadi proyek saya.

Untuk daftar semuanya:

1. Contoh GitLab
2. Repositori kosong, disebut proyek saya
3. Klon lokal dari repositori ini
4. Instance Git lokal Anda dikonfigurasi untuk mendorong perubahan ke dalam terpencil.

Membuat aplikasi Sederhana

Di repositori ini, mari kita buat Node sederhana.aplikasi js. Aplikasi ini adalah Express sederhana.js server yang dimaksudkan untuk digunakan dalam wadah Docker. Server memberikan muatan HTTP yang mengatakan "Halo Dunia" di browser Anda.

Di root repositori lokal Anda, buat file aplikasi.js dan tambahkan baris berikut:

'gunakan ketat';
const ekspres = membutuhkan('ekspres');
// Konstanta
const PORT = 8080;
const HOST = '0.0.0.0';
// Aplikasi
aplikasi const = ekspres();
aplikasi.get('/', (permintaan, res) =>
res.send('Halo dunia\n');
);
aplikasi.mendengarkan(PORT, HOST);
menghibur.log('Berjalan di http://$HOST:$PORT');

Kemudian buat file lain paket.json dan tambahkan yang berikut ini ke dalamnya:

"nama": "docker_web_app",
"versi 1.0.0",
"deskripsi": "Node.js di Docker",
"penulis": "John Doe",
"utama": "server.js",
"skrip":
"mulai": "server simpul.js"
,
"ketergantungan":
"ekspres": "^4.16.1"

Terakhir, buat file docker dan tambahkan konten berikut ke dalamnya:

DARI simpul: 8
# Buat direktori aplikasi
WORKDIR /usr/src/app
# Instal dependensi aplikasi
# Sebuah wildcard digunakan untuk memastikan kedua paket.json DAN kunci paket.json disalin
SALIN paket*.json ./
JALANKAN npm install
# Jika Anda sedang membuat kode untuk produksi
# RUN npm install --only=production
# Bundel sumber aplikasi
SALINAN…
Paparan 8080
CMD [ "simpul", "aplikasi"]

Proses pembuatan untuk aplikasi ini akan melibatkan pembuatan wadah simpul dan menginstal dependensi (seperti Express.modul js). Proses ini harus terjadi tanpa kesalahan. Demi kesederhanaan, kami tidak akan membahas pengujian apa pun dalam tutorial ini.

Saluran GitLab Runner

Sekarang kita akan menambahkan file lain ke repositori kita yang akan disebut .gitlab-ci.yml . File ini akan berisi instruksi untuk membangun proyek kami. Sekarang, setiap kali kami mendorong komit ke instance GitLab kami, GitLab akan memanggil Runner untuk membangun dan menguji proyek.

Kami menetapkan pipa ini berbagai this pekerjaan yang dapat menjalankan semua berjalan secara independen satu sama lain, membuat proses pembuatan lebih fleksibel. Untuk repo di atas, ini valid .gitlab-ci.yml buat file ini di root repositori Anda:

gambar: simpul: terbaru
tahapan:
- membangun
tembolok:
jalur:
- simpul_modul/
install_dependencies:
tahap: membangun
naskah:
- instal npm

Kami hanya memiliki satu tahap membangun dan baru saja instal npm sebagai naskah. Ini adalah perintah yang harus Anda jalankan secara manual setiap kali ada perubahan pada proyek Anda. Pelari GitLab akan melakukan ini untuk Anda. Runner dapat diinstal di cluster Kubernetes, VPS di cloud atau di workstation lokal Anda dan jika aktif, ia akan menunggu instruksi dari server GitLab untuk menjalankan build.

Kami akan menginstal dan mengonfigurasi Runner secara lokal untuk mengotomatiskannya.

Mendapatkan Token Pelari

Buka repositori Anda di GitLab, dan kunjungi pengaturan CD/CI-nya. itu Pengaturan → CD/CI di dalam repositori pengujian Anda.

Biarkan pengaturan Auto DevOps ke default dan klik MEMPERLUAS untuk memperluas pengaturan Pipa Umum dan Anda akan diperlihatkan Token Pelari. Salin nilainya dan, tentu saja, jaga kerahasiaannya jika Anda menghargai proyek Anda.

Dengan menggunakan token ini, GitLab Runner lokal Anda yang dapat dieksekusi akan dapat mendaftar dengan aman dengan instance GitLab Anda.

Menginstal GitLab Runner

GitLab-Runner adalah program ringan kecil yang ditulis dalam Go yang menjalankan terkait CI pekerjaan di mesin lokal Anda dan mengirimkan hasilnya ke GitLab untuk mempertimbangkan perubahannya. Ini adalah biner yang dapat dieksekusi tunggal yang dapat diinstal pada semua OS utama. Ikuti instruksi di sini, untuk Sistem Operasi khusus Anda. Instalasi ini sangat bervariasi sehingga membuat daftar semuanya tidak mungkin.

Atau Anda dapat menggunakan Runner sebagai layanan Docker, tetapi mari kita tetap menggunakan instalasi tradisional, karena perintahnya lebih mudah dibaca dan dipahami oleh pembaca. Setelah Anda menginstalnya di workstation lokal Anda, Anda perlu menjalankan perintah:

$ gitlab-runner register

Ini akan menanyakan beberapa pertanyaan yang dimulai dengan koordinator GitLab-CI Anda yang akan menjadi instance GitLab Anda:

$ gitlab-runner register
Silakan masukkan URL koordinator gitlab-ci (mis.g. https://gitlab.com/):
https://gitlab.contoh.com

Itu kemudian akan meminta Token Pelari Anda, yang kami peroleh di bagian sebelumnya:

Silakan masukkan token gitlab-ci untuk pelari ini:

Token_Rahasia_Anda

Kemudian untuk beberapa deskripsi pengidentifikasi dan Anda dapat melewatkan menambahkan tag apa pun dengan menekan :

Silakan masukkan deskripsi gitlab-ci untuk pelari ini:

[Hostname]: Demo untuk menyiapkan CI menggunakan Runner

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

Mendaftarkan pelari… berhasil

Yang paling penting, itu akan meminta Anda untuk eksekutor (lebih lanjut tentang ini sebentar lagi), kami akan memilih Docker demi contoh kami.

Silakan masukkan eksekutor: docker-ssh+machine, kubernetes, parallels, shell, ssh, virtualbox, docker+machine, docker, docker-ssh:

buruh pelabuhan

Gambar buruh pelabuhan dasar di mana pembangunan akan berlangsung kemudian perlu ditentukan, aplikasi contoh kami menggunakan simpul sehingga kami akan menentukan gambar simpul:

Harap masukkan gambar Docker default (mis.g. rubi: 2.1):

simpul: terbaru

Pelari berhasil terdaftar. Jangan ragu untuk memulainya, tetapi jika sudah berjalan, konfigurasi harus dimuat ulang secara otomatis!

Sekarang sesuatu yang perlu sedikit penjelasan di sini adalah apa sebenarnya pelaksana? Cara kerja CI adalah bahwa pembuatan modul, pengujiannya, dll semuanya dikenal sebagai pekerjaan dan pelaksana menjalankan pekerjaan itu. Jika Anda memilih VirtualBox sebagai eksekutor, runner GitLab akan berintegrasi dengan VirtualBox yang diinstal secara lokal dan menjalankan pekerjaan CI di VM, jika Anda memilih kubernetes maka itu akan terjadi di cluster Kubernetes Anda, di cloud, jika Anda memilih ssh, Anda bisa mendelegasikan tugas CI ke server jauh.

Proyek sampel kami didasarkan pada Docker, jadi masuk akal untuk menggunakan Docker sebagai pelaksana kami. Anda harus memiliki Docker diinstal secara lokal untuk ini.

Memiliki banyak opsi untuk pelaksana membuat Runner lebih fleksibel. Anda mungkin ingin membangun secara lokal karena file proyek terlalu besar atau Anda mungkin ingin mengeksekusi di server jarak jauh dengan 20 inti dan setengah terabyte RAM karena proses pembangunan intensif secara komputasi, menentukan opsi pelaksana memberi Anda fleksibilitas itu.

Terakhir, di shell Anda, Anda ingin memulai layanan Runner:

$ gitlab-runner mulai

Melihat .gitlab-ci.yml beraksi

Sekarang kami telah membuat semua perubahan ini di repo lokal kami membuat semua aplikasi.js, paket.json, Dockerfile dan .gitlab-ci.file yml. Agaknya, Anda melakukan perubahan ke repositori lokal Anda dengan menjalankan:

$ git panggung file_name
$ git commit -m "Pesan Komit"

Mari dorong perubahan ke GitLab jarak jauh kami.

$ git push -u asal

Anda kemudian dapat membuka proyek Anda di GitLab, buka proyek saya → Pipeline dan Anda akan melihat ini sebuah tag yang mengatakan "lulus" di sebelah komit yang Anda buat. Komit berikutnya, juga akan memiliki tag.

Jadi itulah dasar-dasar CI menggunakan GitLab dan Runner. Semoga Anda menikmati posnya dan belajar sesuatu yang baru darinya.