Saya sedang mempelajari pendekatan untuk memahami lebih baik bagaimana alur kerja integrasi berkesinambungan lebih cocok di perusahaan pengembangan perangkat lunak dengan metode scrum.
Saya sedang memikirkan sesuatu seperti ini:
Apakah itu alur kerja yang bagus?
Jawaban:
Anda ada beberapa cara di sana, tapi saya akan sedikit memperluas diagram Anda:
Pada dasarnya (jika kontrol versi Anda mengizinkannya, yaitu jika Anda menggunakan hg / git), Anda ingin setiap pasangan pengembang / pengembang memiliki cabang "pribadi" sendiri, yang berisi kisah pengguna tunggal yang sedang mereka kerjakan. Ketika mereka melengkapi fitur, mereka perlu mendorong ke cabang pusat, cabang "Rilis". Pada titik ini, Anda ingin dev mendapatkan cabang baru, untuk hal selanjutnya yang perlu mereka kerjakan. Cabang fitur asli harus dibiarkan apa adanya, sehingga setiap perubahan yang perlu dilakukan dapat dilakukan secara terpisah (ini tidak selalu berlaku, tetapi ini merupakan titik awal yang baik). Sebelum dev kembali bekerja di cabang fitur lama, Anda harus menarik cabang rilis terbaru, untuk menghindari masalah penggabungan yang aneh.
Pada titik ini, kami memiliki kandidat rilis yang mungkin dalam bentuk cabang "Rilis", dan kami siap menjalankan proses CI kami (pada cabang itu, jelas Anda dapat melakukan ini di setiap cabang pengembang, tetapi ini adalah cukup langka di tim pengembang yang lebih besar karena mengacaukan server CI). Ini mungkin proses yang konstan (ini idealnya, CI harus dijalankan setiap kali cabang "Release" diubah), atau mungkin setiap malam.
Pada titik ini, Anda ingin menjalankan build, dan mendapatkan artefak build yang layak dari server CI (yaitu sesuatu yang layak Anda gunakan). Anda dapat melewati langkah ini jika Anda menggunakan bahasa yang dinamis! Setelah Anda dibangun, Anda akan ingin menjalankan Tes Unit Anda, karena itu adalah dasar dari semua tes otomatis dalam sistem; mereka cenderung cepat (yang bagus, karena seluruh titik CI adalah untuk memperpendek lingkaran umpan balik antara pengembangan dan pengujian), dan mereka tidak membutuhkan penyebaran. Jika mereka lulus, Anda akan ingin secara otomatis menyebarkan aplikasi Anda ke server uji (jika mungkin), dan menjalankan tes integrasi apa pun yang Anda miliki. Tes integrasi dapat berupa tes UI otomatis, tes BDD, atau tes integrasi standar menggunakan kerangka Pengujian Unit (yaitu "unit"
Pada titik ini, Anda harus memiliki indikasi yang cukup komprehensif tentang apakah bangunan itu layak atau tidak. Langkah terakhir yang biasanya saya siapkan dengan cabang "Rilis" adalah untuk membuatnya secara otomatis menyebarkan kandidat rilis ke server pengujian, sehingga departemen QA Anda dapat melakukan tes asap manual (ini sering dilakukan setiap malam alih-alih per-checkin sehingga untuk menghindari mengacaukan siklus tes). Ini hanya memberikan indikasi manusia yang cepat apakah build benar-benar cocok untuk rilis langsung, karena cukup mudah untuk kehilangan hal-hal jika paket tes Anda kurang komprehensif, dan bahkan dengan cakupan uji 100% mudah untuk melewatkan sesuatu yang Anda bisa 't (tidak boleh) menguji secara otomatis (seperti gambar yang tidak sejajar, atau kesalahan ejaan).
Ini, sebenarnya, kombinasi dari Continuous Integration dan Continuous Deployment, tetapi mengingat bahwa fokus dalam Agile adalah pada lean coding dan pengujian otomatis sebagai proses kelas satu, Anda ingin bertujuan untuk mendapatkan pendekatan selengkap mungkin.
Proses yang saya uraikan adalah skenario kasus ideal, ada banyak alasan mengapa Anda mungkin mengabaikan bagian-bagiannya (misalnya, cabang pengembang tidak layak di SVN), tetapi Anda ingin membidik sebanyak mungkin .
Mengenai bagaimana siklus sprint Scrum cocok dengan ini, idealnya Anda ingin rilis Anda terjadi sesering mungkin, dan tidak membiarkannya sampai akhir sprint, karena mendapatkan umpan balik cepat apakah suatu fitur (dan membangun secara keseluruhan) ) layak untuk pindah ke produksi adalah teknik kunci untuk mempersingkat loop umpan balik Anda ke Pemilik Produk Anda.
Secara konseptual, ya. Diagram tidak menangkap banyak poin penting seperti:
Anda mungkin ingin menggambar sistem yang lebih luas untuk diagram. Saya akan mempertimbangkan untuk menambahkan elemen-elemen berikut:
Tampilkan input Anda ke sistem, yang diumpankan ke pengembang. Sebut mereka persyaratan, perbaikan bug, cerita, atau apa pun. Tetapi saat ini alur kerja Anda mengasumsikan pemirsa tahu bagaimana input tersebut dimasukkan.
Tampilkan titik kontrol di sepanjang alur kerja. Siapa / apa yang memutuskan kapan perubahan diizinkan menjadi trunk / main / release-branch / etc ...? Codetrees / proyek apa yang dibangun di CIS? Apakah ada pos pemeriksaan untuk melihat apakah bangunannya rusak? Siapa yang melepaskan CIS ke pentas / produksi?
Terkait dengan poin kontrol adalah mengidentifikasi apa metodologi percabangan Anda dan bagaimana hal itu cocok dengan alur kerja ini.
Apakah ada tim Tes? Kapan mereka terlibat atau diberi tahu? Apakah ada pengujian otomatis yang dilakukan pada CIS? Bagaimana kerusakan diumpankan kembali ke dalam sistem?
Pertimbangkan bagaimana Anda akan memetakan alur kerja ini ke diagram alur tradisional dengan titik keputusan dan input. Sudahkah Anda menangkap semua titik sentuh tingkat tinggi yang diperlukan untuk menggambarkan alur kerja Anda secara memadai?
Pertanyaan awal Anda mencoba untuk membuat perbandingan, saya pikir, tapi saya tidak yakin pada aspek mana yang ingin Anda bandingkan. Integrasi berkelanjutan memiliki poin keputusan seperti model SDLC lainnya, tetapi mereka mungkin berada pada titik yang berbeda dalam proses.
Saya menggunakan istilah "Otomasi Pengembangan" untuk mencakup semua pembuatan otomatis, pembuatan dokumentasi, pengujian, pengukuran kinerja, dan aktivitas penyebaran.
Oleh karena itu, "server otomasi pengembangan" memiliki remit yang serupa, tetapi agak lebih luas daripada server integrasi berkelanjutan.
Saya lebih suka menggunakan skrip otomatisasi pengembangan yang didorong oleh kait pasca-komit yang memungkinkan cabang pribadi dan trunk pengembangan pusat terotomatisasi, tanpa memerlukan konfigurasi tambahan pada server CI. (Ini menghalangi penggunaan sebagian besar GUI server CI off-the-shelf yang saya sadari).
Script post-commit menentukan aktivitas otomatisasi mana yang akan dijalankan berdasarkan konten cabang itu sendiri; baik dengan membaca file konfigurasi pasca-komit di lokasi tetap di cabang, atau dengan mendeteksi kata tertentu (saya menggunakan / otomatis /) sebagai komponen jalur ke cabang di repositori (dengan Svn)).
(Ini lebih mudah diatur dengan Svn daripada Hg).
Pendekatan ini memungkinkan tim pengembangan untuk lebih fleksibel tentang bagaimana mereka mengatur alur kerja mereka, memungkinkan CI untuk mendukung pengembangan pada cabang dengan overhead administrasi minimal (hampir nol).
Ada serangkaian posting yang bagus tentang integrasi berkesinambungan di asp.net yang mungkin berguna bagi Anda, mencakup cukup banyak alur kerja dan alur kerja yang sesuai dengan apa yang Anda cari.
Diagram Anda tidak menyebutkan pekerjaan yang dilakukan oleh server CI (pengujian unit, cakupan kode, dan metrik lainnya, pengujian integrasi atau build malam), tapi saya berasumsi itu semua tercakup dalam tahap "Continuous Integration server". Saya tidak jelas mengapa kotak CI akan mendorong kembali ke repositori pusat? Jelas itu perlu untuk mendapatkan kode tetapi mengapa harus mengirimnya kembali?
CI adalah salah satu dari praktik-praktik yang direkomendasikan oleh berbagai disiplin ilmu, itu tidak unik untuk scrum (atau XP) tetapi sebenarnya saya akan mengatakan itu manfaat yang tersedia untuk aliran apa pun bahkan non-gesit seperti air terjun (mungkin basah-gesit?) . Bagi saya manfaat utama adalah loop umpan balik yang ketat, Anda tahu cukup cepat apakah kode yang baru Anda komit bekerja dengan sisa basis kode. Jika Anda bekerja dalam sprint dan melakukan stand-up harian Anda maka bisa merujuk ke status, atau metrik dari semalam membangun di server CI jelas merupakan nilai tambah dan membantu orang fokus. Jika pemilik produk Anda dapat melihat status build - monitor besar di area bersama yang menunjukkan status proyek build Anda - maka Anda benar-benar memperketat lingkaran umpan balik itu. Jika tim pengembangan Anda sering melakukan (lebih dari sekali sehari dan idealnya lebih dari sekali jam) maka kemungkinan Anda akan mengalami masalah integrasi yang membutuhkan waktu lama untuk diselesaikan berkurang, tetapi jika mereka melakukannya, jelas untuk semua dan Anda dapat mengambil tindakan apa pun yang Anda butuhkan, semua orang berhenti untuk berurusan dengan bangunan yang rusak misalnya. Dalam praktiknya, Anda mungkin tidak akan menemukan banyak bangunan gagal yang membutuhkan waktu lebih dari beberapa menit untuk mencari tahu apakah Anda sering berintegrasi.
Bergantung pada sumber daya / jaringan Anda, Anda mungkin ingin mempertimbangkan untuk menambahkan server akhir yang berbeda. Kami memiliki pembangunan CI yang dipicu oleh komit ke repo dan dengan asumsi bahwa membangun dan melewati semua tes itu kemudian dikerahkan ke server pengembangan sehingga pengembang dapat memastikan bahwa itu berfungsi dengan baik (Anda dapat memasukkan selenium atau pengujian UI lainnya di sini? ). Tidak setiap komit adalah build yang stabil, jadi untuk memicu build ke staging server kita harus menandai revisi (kita menggunakan mercurial) yang ingin kita bangun dan gunakan, sekali lagi ini semua otomatis dan dipicu hanya dengan melakukan dengan tertentu menandai. Untuk menuju produksi adalah proses manual; Anda dapat membiarkannya sesederhana memaksa membangun triknya adalah mengetahui revisi / build mana yang ingin Anda gunakan, tetapi jika Anda menandai revisi dengan tepat maka server CI dapat memeriksa versi yang benar dan melakukan apa pun yang diperlukan. Anda bisa menggunakan MS Deploy untuk menyinkronkan perubahan ke server produksi, atau untuk mengemasnya dan meletakkan zip di suatu tempat yang siap untuk digunakan oleh admin secara manual ... itu tergantung pada seberapa nyaman Anda dengan itu.
Selain naik versi, Anda juga harus mempertimbangkan bagaimana Anda bisa menghadapi kegagalan dan turun versi. Mudah-mudahan itu tidak akan terjadi tetapi mungkin ada beberapa perubahan yang dilakukan pada server Anda yang berarti apa yang bekerja pada UAT tidak bekerja pada produksi, sehingga Anda merilis versi yang disetujui dan gagal ... Anda selalu dapat mengambil pendekatan yang Anda mengidentifikasi bug, tambahkan beberapa kode, komit, uji, sebarkan ke produksi untuk memperbaikinya ... atau Anda bisa membungkus beberapa tes lebih lanjut di sekitar rilis otomatis Anda untuk produksi dan jika gagal itu maka secara otomatis bergulir kembali.
CruiseControl.Net menggunakan xml untuk mengonfigurasi build, TeamCity menggunakan penyihir, jika Anda bertujuan untuk menghindari spesialis di tim Anda, maka kompleksitas konfigurasi xml dapat menjadi hal lain yang perlu diingat.
Pertama, peringatan: Scrum adalah metodologi yang cukup ketat. Saya telah bekerja untuk beberapa organisasi yang telah mencoba menggunakan Scrum, atau pendekatan seperti Scrum tetapi tidak satupun dari mereka benar-benar mendekati menggunakan disiplin penuh secara keseluruhan. Dari pengalaman saya, saya adalah penggemar Agile, tapi skeptis.
Seperti yang saya pahami, Scrum & metode Agile lainnya memiliki dua tujuan utama:
Tujuan pertama (manajemen risiko) dicapai melalui pengembangan berulang; membuat kesalahan dan mempelajari pelajaran dengan cepat, memungkinkan tim untuk membangun pemahaman dan kemampuan intelektual untuk mengurangi risiko dan bergerak menuju solusi risiko rendah dengan solusi "keras" risiko rendah sudah ada di dalam tas.
Pengembangan Otomasi, termasuk integrasi berkelanjutan, adalah faktor paling penting dalam keberhasilan pendekatan ini. Penemuan risiko & pembelajaran harus cepat, bebas gesekan, dan bebas dari faktor sosial yang membingungkan. (Orang-orang belajar JAUH lebih cepat ketika itu adalah mesin yang memberitahu mereka bahwa mereka salah daripada manusia lain - ego hanya menghalangi pembelajaran).
Seperti yang mungkin Anda tahu - saya juga penggemar pengembangan yang digerakkan oleh tes. :-)
Tujuan kedua kurang berkaitan dengan otomatisasi pengembangan, dan lebih banyak berkaitan dengan Faktor Manusia. Lebih sulit untuk diimplementasikan karena memerlukan dukungan dari ujung depan bisnis, yang tidak mungkin melihat kebutuhan akan formalitas.
Otomasi Pengembangan dapat berperan di sini, di mana dokumentasi dan laporan kemajuan yang dihasilkan secara otomatis dapat digunakan untuk menjaga pemangku kepentingan di luar tim pengembangan terus diperbarui dengan kemajuan, dan radiator informasi yang memperlihatkan status build dan lulus / gagal, suite tes dapat digunakan untuk mengkomunikasikan kemajuan tentang pengembangan fitur, membantu (semoga) mendukung adopsi proses komunikasi Scrum.
Jadi, dalam ringkasan:
Diagram yang Anda gunakan untuk menggambarkan pertanyaan Anda hanya menangkap sebagian dari proses. Jika Anda ingin mempelajari gesit / scrum dan CI, saya berpendapat bahwa penting untuk mempertimbangkan aspek sosial dan faktor-faktor manusia yang lebih luas dari proses tersebut.
Saya harus mengakhiri dengan memukul drum yang sama seperti yang selalu saya lakukan. Jika Anda mencoba menerapkan proses yang gesit dalam proyek dunia nyata, prediktor terbaik peluang kesuksesan Anda adalah tingkat otomatisasi yang telah digunakan; itu mengurangi gesekan, meningkatkan kecepatan & membuka jalan menuju kesuksesan.