Bagaimana Tindakan GitHub mengotomatiskan tugas pengembangan?

10 menit

Di sini, kami memperkenalkan GitHub Actions dan alur kerja. Anda mempelajari jenis tindakan yang dapat Anda gunakan dan tempat menemukannya. Anda juga melihat contoh jenis tindakan ini dan bagaimana tindakan tersebut cocok dalam alur kerja.

GitHub mempersingkat waktu dari ide ke penyebaran

GitHub dirancang untuk membantu tim pengembang dan teknisi DevOps membangun dan menyebarkan aplikasi dengan cepat. Ada banyak fitur di GitHub yang memungkinkan efisiensi ini, tetapi umumnya termasuk dalam salah satu dari dua kategori:

Komunikasi: Pertimbangkan semua cara GitHub memudahkan tim pengembang berkomunikasi tentang proyek pengembangan perangkat lunak: tinjauan kode dalam permintaan pull, masalah GitHub, papan proyek, wiki, notifikasi, dan sebagainya.
Automation: Tindakan GitHub memungkinkan tim Anda mengotomatiskan alur kerja di setiap langkah dalam proses pengembangan perangkat lunak, mulai dari integrasi, pengiriman, hingga penyebaran. Bahkan memungkinkan Anda untuk mengotomatiskan penambahan label pada pull request dan memeriksa isu kadaluarsa serta pull request.

Jika digabungkan, fitur-fitur ini memungkinkan ribuan tim pengembangan secara efektif mengurangi jumlah waktu yang dibutuhkan dari ide awal hingga penyebaran.

Menggunakan otomatisasi alur kerja untuk mengurangi waktu pengembangan

Dalam modul ini, kami fokus pada otomatisasi. Mari kita luangkan waktu sejenak untuk memahami bagaimana tim dapat menggunakan otomatisasi untuk mengurangi jumlah waktu yang diperlukan untuk menyelesaikan alur kerja pengembangan dan penyebaran yang khas.

Pertimbangkan semua tugas yang harus terjadi setelah kode ditulis, tetapi sebelum Anda dapat menggunakan kode dengan andal untuk tujuan yang dimaksudkan. Bergantung pada tujuan organisasi Anda, Anda mungkin perlu melakukan satu atau beberapa tugas berikut:

Pastikan kode lulus semua pengujian unit.
Lakukan pemeriksaan kualitas dan kepatuhan kode untuk memastikan kode sumber memenuhi standar organisasi.
Periksa kode dan dependensinya untuk masalah keamanan yang diketahui.
Buat kode dengan mengintegrasikan kode sumber baru dari (berpotensi) beberapa kontributor.
Pastikan perangkat lunak lulus pengujian integrasi.
Tentukan versi build baru.
Kirim biner baru ke lokasi sistem file yang sesuai.
Sebarkan biner baru ke satu atau beberapa server.
Tentukan apakah salah satu tugas ini tidak lulus, dan laporkan masalah ke individu atau tim yang tepat untuk penyelesaian.

Tantangannya adalah melakukan tugas-tugas ini dengan andal, konsisten, dan berkelanjutan. Proses ini adalah pekerjaan yang ideal untuk otomatisasi alur kerja. Jika Anda sudah mengandalkan GitHub, Anda mungkin ingin menyiapkan otomatisasi alur kerja menggunakan GitHub Actions.

Apa itu Tindakan GitHub?

GitHub Actions adalah skrip paket untuk mengotomatiskan tugas dalam alur kerja pengembangan perangkat lunak di GitHub. Anda dapat mengonfigurasi GitHub Actions untuk memicu alur kerja kompleks yang memenuhi kebutuhan organisasi Anda. Pemicu dapat terjadi setiap kali pengembang memeriksa kode sumber baru ke cabang tertentu, pada interval waktu, atau secara manual. Hasilnya adalah alur kerja otomatis yang andal dan berkelanjutan, yang menyebabkan penurunan waktu pengembangan yang signifikan.

Di mana Anda dapat menemukan Actions GitHub?

Tindakan GitHub adalah skrip yang mematuhi format data yml. Setiap repositori memiliki tab Tindakan yang menyediakan cara cepat dan mudah untuk mulai menyiapkan skrip pertama Anda. Jika Anda melihat alur kerja yang menurut Anda mungkin merupakan titik awal yang bagus, cukup pilih tombol Konfigurasikan untuk menambahkan skrip dan mulai mengedit yml sumber.

Cuplikan layar *tab Tindakan* di GitHub Actions yang menampilkan alur kerja sederhana dan tombol untuk menyiapkan alur kerja ini.

Namun, di luar Tindakan GitHub yang ditampilkan pada tab Tindakan, Anda dapat:

Mencari Tindakan GitHub di Marketplace GitHub. GitHub Marketplace memungkinkan Anda menemukan dan membeli alat yang memperluas alur kerja Anda.
Mencari proyek sumber terbuka. Misalnya, organisasi Tindakan GitHub menampilkan banyak repositori sumber terbuka populer yang berisi Tindakan GitHub yang dapat Anda gunakan.
Menulis Tindakan GitHub Anda sendiri dari awal. Anda dapat membuatnya sumber terbuka, atau bahkan menerbitkannya ke GitHub Marketplace.

Menggunakan GitHub Actions sumber terbuka

Banyak Tindakan GitHub yang merupakan sumber terbuka dan tersedia bagi siapa saja yang ingin menggunakannya. Namun, sama seperti perangkat lunak sumber terbuka yang lain, Anda perlu memeriksanya dengan hati-hati sebelum menggunakannya dalam proyek. Mirip dengan standar komunitas yang direkomendasikan dengan perangkat lunak sumber terbuka seperti termasuk README, kode etik, file kontribusi, dan templat masalah, Anda dapat mengikuti rekomendasi ini saat menggunakan GitHub Actions:

Tinjau file tindakan action.yml untuk input, output, serta memastikan kode melakukan apa yang seharusnya.
Periksa apakah tindakan berada di Marketplace GitHub. Pemeriksaan ini bermanfaat, meskipun tindakan tidak harus berada di GitHub Marketplace untuk dianggap valid.
Periksa apakah tindakan telah diverifikasi di Marketplace GitHub. Verifikasi berarti GitHub menyetujui penggunaan tindakan ini. Namun, Anda masih harus meninjaunya sebelum menggunakannya.
Menyertakan versi tindakan yang Anda gunakan dengan menentukan Git ref, SHA, atau tag.

Jenis tindakan GitHub

Ada tiga jenis tindakan GitHub: tindakan kontainer, tindakan JavaScript, dan tindakan komposit.

Dengan tindakan kontainer, lingkungan adalah bagian dari kode tindakan. Tindakan ini hanya dapat dijalankan di lingkungan Linux yang dihost oleh GitHub. Tindakan kontainer mendukung banyak bahasa yang berbeda.

Tindakan JavaScript tidak menyertakan lingkungan dalam kode. Anda harus menentukan lingkungan untuk menjalankan tindakan ini. Anda dapat menjalankan tindakan ini di VM (komputer virtual) di cloud atau lokal. Tindakan JavaScript mendukung lingkungan Linux, macOS, dan Windows.

Tindakan komposit memungkinkan Anda menggabungkan beberapa langkah alur kerja dalam satu tindakan. Misalnya, Anda dapat menggunakan fitur ini untuk menggabungkan beberapa perintah eksekusi ke dalam tindakan, lalu memiliki alur kerja yang menjalankan perintah yang dibundel sebagai langkah tunggal menggunakan tindakan tersebut.

Anatomi tindakan GitHub

Berikut adalah contoh tindakan yang melakukan git checkout dari repositori. Tindakan ini, tindakan/checkout@v1, adalah bagian dari langkah dalam alur kerja. Langkah ini juga membangun kode Node.js yang telah diperiksa. Kita akan membahas alur kerja, pekerjaan, dan langkah-langkah di bagian berikutnya.

steps:
  - uses: actions/checkout@v1
  - name: npm install and build webpack
    run: |
      npm install
      npm run build

Misalnya Anda ingin menggunakan tindakan kontainer untuk menjalankan kode kontainer. Tindakan Anda mungkin terlihat seperti ini:

name: "Hello Actions"
description: "Greet someone"
author: "octocat@github.com"

inputs:
    MY_NAME:
      description: "Who to greet"
      required: true
      default: "World"

runs:
    uses: "docker"
    image: "Dockerfile"

branding:
    icon: "mic"
    color: "purple"

Perhatikan bagian inputs. Di sini, Anda mendapatkan nilai variabel yang disebut MY_NAME. Variabel ini diatur dalam alur kerja yang menjalankan tindakan ini.

Di bagian runs, perhatikan bahwa Anda menentukan docker di atribut uses. Saat Anda mengatur nilai ini, Anda perlu memberikan jalur ke file gambar Docker. Dalam hal ini, Dockerfile. Kami tidak membahas spesifik Docker di sini, tetapi jika Anda ingin informasi lebih lanjut, lihat pengantar modul Kontainer Docker .

Bagian terakhir, branding, mempersonalisasi tindakan Anda di Marketplace GitHub jika Anda memutuskan untuk menerbitkannya di sana.

Anda dapat menemukan daftar lengkap metadata tindakan di sintaks Metadata untuk Tindakan GitHub.

Apa itu alur kerja GitHub Actions?

Alur kerja Tindakan GitHub adalah proses yang Anda siapkan di repositori untuk mengotomatiskan tugas siklus hidup pengembangan perangkat lunak, termasuk Tindakan GitHub. Dengan alur kerja, Anda dapat membuat, menguji, mengemas, merilis, dan menyebarkan proyek apa pun di GitHub.

Untuk membuat alur kerja, Anda menambahkan tindakan ke file YAML di direktori .github/workflows di repositori GitHub.

Dalam latihan yang akan datang, file alur kerja Anda main.yml terlihat seperti contoh ini:

name: A workflow for my Hello World file
on: push
jobs:
  build:
    name: Hello world action
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v1
    - uses: ./action-a
      with:
        MY_NAME: "Mona"

on: Perhatikan atribut , nilainya adalah pemicu untuk menentukan kapan alur kerja ini berjalan. Di sini, pemicu akan menjalankan eksekusi saat ada push event ke repositori Anda. Anda dapat menentukan satu peristiwa seperti on: push, array peristiwa seperti on: [push, pull_request], atau peta konfigurasi peristiwa yang menjadwalkan alur kerja atau membatasi eksekusi alur kerja ke file, tag, atau perubahan cabang tertentu. Peta dapat terlihat seperti berikut:

on:
  # Trigger the workflow on push or pull request,
  # but only for the main branch
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
  # Also trigger on page_build, as well as release created events
  page_build:
  release:
    types: # This configuration doesn't affect the page_build event above
      - created

Peristiwa memicu semua jenis aktivitas untuk peristiwa kecuali Anda menentukan jenis atau jenisnya. Untuk daftar lengkap peristiwa dan jenis aktivitasnya, lihat: Peristiwa yang memicu alur kerja dalam dokumentasi GitHub.

Alur kerja harus memiliki setidaknya satu pekerjaan. Pekerjaan adalah bagian dari alur kerja yang terkait dengan runner. Runner dapat di-hosting oleh GitHub atau di-hosting sendiri, dan tugas dapat dijalankan di mesin atau di dalam kontainer. Anda menentukan pelari dengan atribut runs-on:. Di sini, Anda memberi tahu alur kerja untuk menjalankan pekerjaan ini di ubuntu-latest.

Setiap pekerjaan memiliki langkah-langkah untuk diselesaikan. Dalam contoh kita, langkah ini menggunakan actions/checkout@v1 untuk memeriksa repositori. Yang menarik adalah nilai uses: ./action-a, yang merupakan jalur ke tindakan kontainer yang Anda buat dalam file action.yml.

Bagian terakhir dari file alur kerja ini mengatur MY_NAME nilai variabel untuk alur kerja ini. Ingat tindakan kontainer mengambil input yang disebut MY_NAME.

Untuk informasi selengkapnya tentang sintaks alur kerja, lihat Sintaks alur kerja untuk GitHub Actions

Mereferensikan tindakan dalam alur kerja

Saat membuat alur kerja di GitHub Actions, Anda dapat mereferensikan tindakan dari berbagai sumber. Tindakan ini dapat digunakan untuk mengotomatiskan tugas di alur kerja Anda. Di bawah ini adalah sumber utama tempat alur kerja dapat mereferensikan tindakan:

Gambar kontainer Docker yang diterbitkan di Docker Hub
Alur kerja dapat mereferensikan tindakan yang diterbitkan sebagai gambar kontainer Docker di Docker Hub. Tindakan ini dikontainerisasi dan mencakup semua dependensi yang diperlukan untuk menjalankan tindakan. Untuk menggunakan tindakan seperti itu, Anda menentukan gambar Docker di uses atribut langkah alur kerja Anda. Contohnya:
```
steps:
  - name: Run a Docker action
    uses: docker://<docker-image-name>:<tag>
```
Repositori publik apa pun
Tindakan yang dihosting di repositori publik dapat langsung direferensikan dalam alur kerja Anda. Tindakan ini dapat diakses oleh siapa saja dan dapat digunakan dengan menentukan nama dan versi repositori (Git ref, SHA, atau tag) dalam uses atribut . Contohnya:
```
steps:
  - name: Use a public action
    uses: actions/checkout@v3
```

[!PENTING]

Untuk keamanan yang lebih baik, gunakan SHA penerapan penuh saat mereferensikan tindakan—bukan hanya tag seperti @v3.
Ini memastikan alur kerja Anda selalu menggunakan kode yang sama persis, bahkan jika tindakan diperbarui atau diubah nanti.
Contoh: uses: actions/checkout@c2c1744e079e0dd11c8e0af4a96064ca4f6a2e9e

Repositori yang sama dengan file alur kerja Anda
Anda dapat mereferensikan tindakan yang disimpan di repositori yang sama dengan file alur kerja Anda. Fitur ini berguna untuk tindakan kustom yang khusus untuk proyek Anda. Untuk mereferensikan tindakan tersebut, gunakan jalur relatif ke direktori tindakan. Misalnya:
```
steps:
  - name: Use a local action
    uses: ./path-to-action
```

Untuk detail selengkapnya, lihat panduan penguatan keamanan untuk GitHub Actions.

Marketplace perusahaan
Jika organisasi Anda menggunakan GitHub Enterprise, Anda dapat mereferensikan tindakan dari marketplace privat perusahaan Anda. Tindakan ini dikumpulkan dan dikelola oleh organisasi Anda, memastikan kepatuhan terhadap standar internal. Misalnya:
```
steps:
  - name: Use an enterprise marketplace action
    uses: enterprise-org/action-name@v1
```

Nota

Tindakan di repositori privat juga dapat direferensikan, tetapi memerlukan autentikasi dan izin yang tepat.
Saat mereferensikan tindakan, selalu tentukan versi (Git ref, SHA, atau tag) untuk memastikan konsistensi dan menghindari perubahan yang tidak terduga.

Untuk informasi selengkapnya, lihat Mereferensikan tindakan dalam alur kerja.

Runner yang dihosting oleh GitHub versus yang dihosting sendiri

Kita telah secara singkat menyebut bahwa pelari berhubungan dengan suatu pekerjaan. Runner adalah server yang memiliki aplikasi runner GitHub Actions terpasang. Dalam contoh alur kerja sebelumnya, atribut runs-on: ubuntu-latest dalam blok pekerjaan tersebut memberi tahu alur kerja bahwa pekerjaan tersebut akan dijalankan menggunakan runner yang dihosting di GitHub dan berjalan di lingkungan ubuntu-latest.

Dalam hal pelari, ada dua opsi untuk dipilih: Pelari yang dihosting GitHub atau pelari yang dihost sendiri. Jika Anda menggunakan runner yang di-host oleh GitHub, setiap pekerjaan berjalan dalam sebuah instans lingkungan virtual yang baru. Jenis runner yang dihosting di GitHub yang Anda tentukan kemudian menentukan lingkungan tersebut. Dengan runner yang dihost sendiri, Anda perlu menerapkan label yang dihost sendiri, sistem operasinya, dan arsitektur sistemnya. Misalnya, runner yang dihost sendiri dengan sistem operasi Linux dan arsitektur ARM32 akan terlihat seperti spesifikasi berikut: runs-on: [self-hosted, linux, ARM32].

Setiap jenis runner memiliki manfaatnya, tetapi pelari yang dihosting GitHub menawarkan cara yang lebih cepat dan lebih sederhana untuk menjalankan alur kerja Anda, meskipun dengan opsi terbatas. Runner yang dihost sendiri adalah cara yang dapat dikonfigurasi dengan baik untuk menjalankan alur kerja di lingkungan lokal kustom Anda sendiri. Anda dapat menjalankan runner yang dihosting sendiri secara lokal atau di cloud. Anda juga dapat menggunakan runner yang di-host sendiri untuk membuat konfigurasi perangkat keras kustom dengan lebih banyak daya pemrosesan atau memori. Jenis konfigurasi ini membantu menjalankan pekerjaan yang lebih besar, menginstal perangkat lunak yang tersedia di jaringan lokal Anda, dan memilih sistem operasi yang tidak ditawarkan oleh runner yang dihosting GitHub.

GitHub Actions dapat memiliki batas penggunaan

GitHub Actions memang memiliki beberapa batas penggunaan, tergantung pada paket GitHub Anda dan apakah runner Anda dihosting GitHub atau dihost sendiri. Untuk informasi selengkapnya tentang batas penggunaan, lihat Batas penggunaan, penagihan, dan administrasi dalam dokumentasi GitHub.

GitHub menghosting pelari yang lebih besar

GitHub menawarkan runner yang lebih besar untuk alur kerja yang memerlukan lebih banyak sumber daya. Pelari ini di-hosting oleh GitHub dan menyediakan peningkatan kekuatan CPU, memori, dan ruang disk dibandingkan dengan pelari standar. Mereka dirancang untuk menangani alur kerja intensif sumber daya secara efisien, memastikan performa optimal untuk tugas yang menuntut.

Ukuran dan label pelari

Runner yang lebih besar tersedia dalam beberapa konfigurasi, menyediakan penyimpanan vCPU, RAM, dan SSD yang ditingkatkan untuk memenuhi persyaratan alur kerja yang beragam. Konfigurasi ini sangat ideal untuk skenario seperti:

Mengkompilasi basis kode besar dengan file sumber yang luas.
Menjalankan rangkaian pengujian komprehensif, termasuk integrasi dan pengujian end-to-end.
Memproses himpunan data besar untuk analisis data atau tugas pembelajaran mesin.
Membangun aplikasi dengan dependensi kompleks atau output biner besar.
Melakukan simulasi berkinerja tinggi atau pemodelan komputasi.
Menjalankan pengodean video, penyajian, atau alur kerja pemrosesan multimedia lainnya.

Untuk menggunakan runner yang lebih besar, tentukan label runner yang diinginkan dalam atribut runs-on di file alur kerja Anda. Misalnya, untuk menggunakan runner dengan 16 vCPU dan RAM 64 GB, Anda akan mengatur runs-on: ubuntu-latest-16core.

jobs:
  build:
    runs-on: ubuntu-latest-16core
    steps:
      - uses: actions/checkout@v2
      - name: Build project
        run: make build

Runner yang lebih besar ini mempertahankan kompatibilitas dengan alur kerja yang ada dengan menyertakan alat yang telah diinstal sebelumnya yang sama dengan pelari standar ubuntu-latest .

Untuk informasi selengkapnya tentang ukuran runner untuk runner yang lebih besar, lihat dokumentasi GitHub

Mengelola pelari yang lebih besar

GitHub menyediakan alat untuk mengelola pelari yang lebih besar secara efektif, memastikan pemanfaatan sumber daya yang optimal dan manajemen biaya. Berikut adalah beberapa aspek utama dalam mengelola pelari yang lebih besar:

Memantau penggunaan

Anda dapat memantau penggunaan runner yang lebih besar melalui halaman penggunaan GitHub Actions di pengaturan repositori atau di pengaturan organisasi Anda. Halaman ini memberikan wawasan tentang jumlah pekerjaan yang dijalankan, total runtime, dan biaya terkait.

Mengelola akses

Untuk mengontrol akses ke runner dengan kapasitas lebih besar, Anda dapat mengonfigurasi kebijakan tingkat repositori atau organisasi. Konfigurasi ini memastikan bahwa hanya alur kerja atau tim yang berwenang yang dapat menggunakan pelari sumber daya tinggi ini.

Manajemen biaya

Pelari yang lebih besar dikenakan biaya tambahan berdasarkan penggunaannya. Untuk mengelola biaya, pertimbangkan saran berikut:

Gunakan runner yang lebih besar hanya untuk alur kerja yang memerlukan sumber daya yang besar.
Kurangi runtime dengan mengoptimalkan alur kerja.
Pantau detail penagihan secara teratur untuk melacak pengeluaran.

Menskalakan alur kerja

Jika alur kerja Anda memerlukan penggunaan runner yang lebih besar secara berkala, pertimbangkan strategi penskalaan seperti:

Menggunakan runner yang dihost sendiri untuk beban kerja yang dapat diprediksi.
Memisahkan alur kerja menjadi pekerjaan yang lebih kecil untuk mendistribusikan beban di semua penggerak standar.

Saran dan Komentar

Apakah halaman ini membantu?