Git dalam DevOps: Mengapa Version Control Penting?

Mengenal Git dalam DevOps: Mengapa Version Control Penting?

October 6, 2026
oleh Maulana Aldi Pradana

Pendahuluan

Ada kesalahan yang hampir semua orang pernah lakukan: menghapus atau mengubah file yang ternyata masih dibutuhkan. Setelah itu, muncul pertanyaan sederhana tetapi sulit dijawab: versi sebelumnya ada di mana?

Masalah seperti ini biasanya terjadi ketika perubahan file tidak memiliki sistem pencatatan yang jelas. Setiap orang dapat menyimpan salinan sendiri dengan nama berbeda, tetapi tidak ada cara yang rapi untuk mengetahui siapa yang mengubah file, kapan perubahan dilakukan, dan apa yang sebenarnya berubah.

Dalam pengembangan software, masalah tersebut menjadi lebih serius. Kode dapat berubah berkali-kali dalam satu hari, dikerjakan oleh beberapa orang, lalu digunakan sebagai bagian dari proses pengujian hingga deployment. Ketika terjadi masalah, tim perlu mengetahui perubahan mana yang menyebabkan masalah dan versi mana yang masih stabil.

Di sinilah version control dibutuhkan.

Git dalam DevOps merupakan salah satu konsep dasar yang penting dipahami sebelum mempelajari workflow DevOps yang lebih lanjut. Sebagai distributed version control system, Git digunakan untuk mencatat perubahan file, menyimpan riwayatnya, dan membantu developer bekerja dengan versi kode secara terstruktur.

Pada artikel ini, kita akan mempelajari Git dari dasar melalui praktik langsung menggunakan project sederhana. Praktik tersebut dimulai dari membuat repository, memeriksa perubahan, membuat commit, melihat riwayat, menghubungkan repository lokal dengan GitHub, hingga memverifikasi hasil push.

📘 Apa yang Akan Dipelajari?

Pada artikel ini, kita akan mempelajari:

Konsep version control dan masalah yang diselesaikannya.
Git sebagai distributed version control system.
Istilah penting seperti repository, commit, branch, dan remote.
Cara kerja working directory, staging area, dan repository.
Penggunaan git init, git status, git add, git commit, git diff, dan git log.
Cara menghubungkan repository lokal dengan GitHub.
Cara melakukan git push ke repository remote.
Cara memverifikasi repository lokal dan remote.
Temuan nyata dari pengujian pola .gitignore.
Hubungan Git dengan workflow CI/CD.

❓ Mengapa Git Penting dalam DevOps?

Bayangkan sebuah project dikerjakan oleh beberapa orang. Satu developer mengubah halaman utama, developer lain memperbaiki konfigurasi, dan developer lain menambahkan fitur baru.

Tanpa version control, perubahan tersebut mudah menjadi sulit dilacak.

Alurnya dapat digambarkan seperti berikut:

Ilustrasi alur masalah — bukan output perintah terminal.

Beberapa orang mengubah satu project
              ↓
File yang sama berubah dari beberapa arah
              ↓
Tidak ada catatan perubahan yang jelas
              ↓
Terjadi masalah pada versi terbaru
              ↓
Sulit mengetahui versi stabil sebelumnya

Dengan version control, situasinya berbeda. Setiap perubahan dapat dicatat sebagai bagian dari riwayat repository. Ketika terjadi masalah, tim dapat memeriksa commit yang dibuat sebelum masalah muncul.

Artinya, pertanyaannya tidak lagi sekadar:

“Versi mana yang benar?”

Tetapi dapat berubah menjadi:

“Commit mana yang terakhir diketahui stabil?”

Git juga memberikan traceability, yaitu kemampuan untuk menelusuri perubahan. Riwayat commit dapat menunjukkan perubahan yang dibuat dan informasi yang berkaitan dengan perubahan tersebut.

Hal ini sangat penting dalam workflow DevOps karena proses pengembangan software tidak berhenti pada penulisan kode. Perubahan kode nantinya dapat menjadi input untuk proses pengujian, build, dan deployment otomatis.

Namun, ada satu hal yang perlu dipahami sejak awal:

Git bukan CI/CD.

Git bertugas sebagai version control. Sementara itu, CI/CD merupakan lapisan terpisah yang dapat membaca perubahan dari repository Git dan kemudian menjalankan proses otomatis seperti test, build, atau deployment.

Git adalah fondasinya, bukan mesin CI/CD itu sendiri.

📖 Apa Itu Version Control?

Version control adalah cara mengelola perubahan pada file secara sistematis.

Tanpa version control, seseorang mungkin membuat banyak salinan file seperti:

project-final
project-final-revisi
project-final-revisi-2
project-final-benar
project-final-benar-terbaru

Cara seperti itu memang dapat bekerja untuk project yang sangat sederhana, tetapi akan cepat membingungkan ketika jumlah perubahan semakin banyak.

Version control menyelesaikan masalah tersebut dengan menyimpan riwayat perubahan secara terstruktur.

Tiga kemampuan utama yang diberikan version control adalah:

Riwayat — mengetahui perubahan yang dilakukan dan kapan perubahan tersebut terjadi.
Kolaborasi — membantu beberapa orang bekerja pada project yang sama.
Rollback — memungkinkan project dikembalikan ke kondisi sebelumnya ketika diperlukan.

Dalam pengembangan software, ketiga kemampuan tersebut sangat penting karena kode terus mengalami perubahan.

📖 Apa Itu Git?

Git adalah distributed version control system yang dibuat oleh Linus Torvalds pada 2005.

Istilah distributed berarti setiap repository hasil clone memiliki salinan repository beserta riwayat yang dibutuhkan untuk bekerja secara lokal. Dengan demikian, banyak operasi Git dapat dilakukan tanpa harus selalu terhubung ke internet.

Salah satu hal penting yang perlu dibedakan adalah Git dan GitHub.

Git adalah program version control yang berjalan di komputer.
GitHub adalah platform untuk menyimpan dan mengelola repository Git secara remote.
Git dapat digunakan tanpa GitHub. GitHub merupakan salah satu platform hosting untuk repository Git, bukan bagian dari Git itu sendiri.

Dalam Git dalam DevOps, perbedaan ini penting karena workflow biasanya melibatkan repository lokal dan repository remote.

📦 Repository, Commit, Branch, dan Remote

Ada empat istilah yang akan sering muncul ketika bekerja dengan Git.

Istilah	Arti
Repository	Kumpulan file project beserta riwayat versinya
Commit	Titik perubahan yang dicatat dalam repository
Branch	Jalur kerja yang menunjuk ke rangkaian commit
Remote	Repository yang berada di server atau platform hosting

Repository

Repository Git ditandai dengan adanya folder .git di dalam project.

Folder .git menyimpan informasi internal yang digunakan Git untuk mengelola riwayat repository. Karena itu, menghapus folder tersebut bukan tindakan biasa: riwayat Git pada repository tersebut juga akan hilang dari working copy.

Commit

Commit merupakan titik perubahan yang dicatat oleh Git.

Setiap commit mempunyai identitas berupa hash, misalnya:

72e11af

Hash tersebut digunakan untuk mengidentifikasi commit tertentu.

Branch

Branch dapat dipahami sebagai jalur pengembangan yang menunjuk ke commit tertentu. Dengan branch, pekerjaan dapat dikembangkan secara terpisah dari jalur utama.

Dalam praktik ini, branch utama yang digunakan adalah main.

Remote

Remote merupakan repository yang berada di lokasi lain, biasanya server atau platform hosting seperti GitHub.

Melalui remote, repository lokal dapat disinkronkan dengan repository yang berada di server.

⚙️ Bagaimana Git Bekerja?

Salah satu konsep yang sering membingungkan pemula adalah bahwa file yang diubah tidak langsung menjadi commit.

Git memiliki beberapa tahapan utama:

Ilustrasi alur kerja Git — bukan output perintah terminal.

WORKING DIRECTORY       STAGING AREA           REPOSITORY
(file yang diedit)  →   (file yang dipilih)  →  (riwayat tersimpan)
                         git add                 git commit

Working Directory

Working directory adalah folder project tempat file berada dan tempat kita melakukan perubahan.

Sebagai contoh, ketika index.html diedit, perubahan tersebut pertama kali berada di working directory.

Staging Area

Staging area merupakan area sementara untuk menentukan perubahan mana yang akan dimasukkan ke commit berikutnya.

Perintah yang digunakan adalah:

git add index.html

Repository

Setelah perubahan dimasukkan ke staging area, perubahan tersebut dapat dicatat menjadi commit:

git commit -m "pesan commit"

Selain itu, terdapat hubungan antara repository lokal dan remote:

Ilustrasi alur sinkronisasi — bukan output perintah terminal.

LOCAL REPOSITORY  ──── git push ────▶  REMOTE REPOSITORY
 (komputer kamu)                         (GitHub)

                   ◀──── git pull ─────

git push digunakan untuk mengirim perubahan dari repository lokal ke remote, sedangkan git pull digunakan untuk mengambil perubahan dari remote dan mengintegrasikannya ke working copy sesuai workflow yang digunakan.

💻 Persiapan Praktik

Praktik ini menggunakan project sederhana bernama:

devops-git-demo

Struktur awal project:

devops-git-demo/
├── README.md
├── index.html
└── .gitignore

index.html merupakan halaman statis sederhana tanpa framework, tanpa <script>, dan tanpa dependensi eksternal.

Karena itu, halaman tersebut digunakan sebagai objek praktik agar perubahan file dapat terlihat dengan jelas.

Caption: Tampilan index.html sebagai project sederhana yang digunakan untuk praktik Git.

Yang perlu disiapkan:

Terminal di Linux untuk menjalankan perintah Git.
Git, dengan versi yang digunakan pada praktik ini adalah git version 2.52.0.
Akun GitHub untuk repository remote.
SSH key yang telah dikonfigurasi untuk autentikasi ke GitHub.

Sebelum membuat commit, identitas Git perlu dikonfigurasi:

git config --global user.name "Nama Kamu"
git config --global user.email "[email protected]"

Jika identitas belum tersedia, Git dapat menolak proses commit dengan pesan Author identity unknown.

📌 Praktik Git pada Project

Sekarang kita masuk ke praktik langsung. Setiap tahap akan memperlihatkan perintah, hasilnya, dan alasan mengapa tahap tersebut penting.

Kondisi Project Sebelum Git

Sebelum Git digunakan, project hanya berupa folder biasa. Belum ada repository dan belum ada riwayat perubahan.

Periksa isi folder:

ls -la

Kondisi project sebelum Git digunakan. Folder belum memiliki .git.

Hal penting yang perlu diperhatikan adalah tidak adanya folder .git.

Ketiadaan folder tersebut berarti folder ini belum menjadi repository Git.

Membuat Repository dengan `git init`

Masuk ke project kemudian inisialisasi Git:

cd ~/devops-git-demo
git init -b main

Output yang diperoleh:

Initialized empty Git repository in /home/maulana/devops-git-demo/.git/

Setelah git init, folder .git dibuat sebagai bagian dari repository Git.

Untuk memastikan branch yang aktif:

git branch --show-current

Output:

main

Perintah git init -b main membuat repository baru dengan branch awal bernama main.

Yang berubah pada tahap ini adalah struktur internal repository. File project seperti README.md, index.html, dan .gitignore tetap menjadi file project biasa.

Memeriksa Status dengan `git status`

Selanjutnya, setelah repository dibuat, kita dapat melihat kondisi project:

git status

Output:

On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	.gitignore
	README.md
	index.html

nothing added to commit but untracked files present (use "git add" to track)

git status menunjukkan tiga file masih berstatus untracked.

Pesan No commits yet menunjukkan bahwa repository belum memiliki commit.

Sementara itu, untracked berarti file tersebut ada di dalam folder project, tetapi belum dilacak oleh Git.

Versi singkat dari status juga dapat digunakan:

git status --short

Output:

?? .gitignore
?? README.md
?? index.html

Tanda ?? menunjukkan file yang belum dilacak.

Memasukkan File ke Staging Area

Sekarang kita masukkan satu file ke staging area:

git add index.html
git status

Output:

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
	new file:   index.html

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	.gitignore
	README.md

index.html sudah masuk staging area, sedangkan dua file lainnya masih untracked.

Perubahan tersebut menunjukkan fungsi staging area.

index.html sudah dipilih untuk masuk ke commit, sedangkan README.md dan .gitignore belum.

Untuk melihat ringkasan perubahan yang sedang berada di staging area:

git diff --staged --stat

Output:

 index.html | 101 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 101 insertions(+)

Karena index.html merupakan file baru bagi repository, seluruh 101 baris dianggap sebagai penambahan.

Membuat Commit Pertama

Setelah memahami staging area, seluruh file project dapat dimasukkan ke staging:

git add .

Kemudian buat commit:

git commit -m "feat: tambah halaman demo, README, dan gitignore"

Output:

[main (root-commit) 0ee624f] feat: tambah halaman demo, README, dan gitignore
 3 files changed, 174 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 README.md
 create mode 100644 index.html

Commit pertama berhasil dibuat dan mencatat tiga file project.

Ada beberapa informasi penting dari output tersebut.

root-commit menunjukkan bahwa ini adalah commit pertama.
0ee624f merupakan identitas singkat commit.
3 files changed menunjukkan tiga file masuk ke commit.
create mode menunjukkan file-file tersebut baru dicatat oleh repository.

Pesan commit juga sebaiknya dibuat deskriptif. Prefix seperti feat:, fix:, docs:, dan chore: merupakan konvensi yang umum digunakan untuk membantu menjelaskan jenis perubahan.

Melakukan Perubahan pada Project

Setelah commit pertama dibuat, index.html diubah.

Perubahannya adalah menambahkan satu item pada daftar materi dan menaikkan penanda revisi dari Revisi 1 menjadi Revisi 2.

Ukuran file berubah dari 2549 menjadi 2615 byte.

Periksa status:

git status

Output:

On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   index.html

no changes added to commit (use "git add" and/or "git commit -a")

Status M menunjukkan bahwa index.html sudah pernah dilacak dan di-commit, tetapi sekarang isinya berbeda dari versi terakhir yang tersimpan di repository.

Melihat Perubahan dengan `git diff`

git status hanya memberitahu file mana yang berubah. Namun, untuk melihat isi perubahan secara lebih detail, gunakan:

git diff

Bagian penting dari hasilnya:

diff --git a/index.html b/index.html
index 08debb3..17991c8 100644
--- a/index.html
+++ b/index.html
@@ -90,10 +90,11 @@
       <li>Mencatat versi file dengan <code>git commit</code></li>
       <li>Membaca riwayat perubahan dengan <code>git log</code></li>
       <li>Menghubungkan repository lokal ke GitHub dan melakukan <code>git push</code></li>
+      <li>Menyimpan beberapa versi file dan membandingkannya</li>
 </ul>

 <footer>
-      Revisi 1 &mdash; dibuat sebagai bahan praktik artikel
+      Revisi 2 &mdash; dibuat sebagai bahan praktik artikel

git diff memperlihatkan baris yang ditambahkan dan dihapus pada index.html.

Cara membacanya cukup sederhana:

Baris dengan tanda + merupakan baris yang ditambahkan.
Baris dengan tanda - merupakan baris yang dihapus.
Baris tanpa tanda tersebut merupakan konteks agar perubahan lebih mudah dibaca.

Dari diff tersebut terlihat bahwa Revisi 1 diganti menjadi Revisi 2 dan satu item materi baru ditambahkan.

Membuat Commit Kedua

Setelah perubahan diperiksa, masukkan file ke staging:

git add index.html

Kemudian buat commit kedua:

git commit -m "docs: tambah daftar materi dan naikkan revisi halaman ke 2"

Output:

[main 72e11af] docs: tambah daftar materi dan naikkan revisi halaman ke 2
 1 file changed, 2 insertions(+), 1 deletion(-)

Commit kedua hanya berisi perubahan pada index.html.

Mau Kuasai Mengenal Git dalam DevOps: Mengapa Version Control Penting? Sampai Bisa Praktik Langsung?

Materi ini juga kami ajarkan langsung di kelas Edusoft Center, dibimbing mentor, sampai kamu bisa praktik nyata — bukan cuma baca teori.

Tanya Kursus via WhatsApp Lihat contoh project nyata dari siswa kami →

Angka tersebut sesuai dengan hasil git diff: dua baris ditambahkan dan satu baris dihapus.

Dengan demikian, repository sekarang memiliki dua titik riwayat:

72e11af  docs: tambah daftar materi dan naikkan revisi halaman ke 2
0ee624f  feat: tambah halaman demo, README, dan gitignore

Melihat Riwayat dengan `git log`

Untuk melihat riwayat commit:

git log --oneline --decorate --graph

Hasil pada repository lokal:

* 72e11af (HEAD -> main) docs: tambah daftar materi dan naikkan revisi halaman ke 2
* 0ee624f feat: tambah halaman demo, README, dan gitignore

git log menampilkan dua commit pada branch main.

Selanjutnya, ada beberapa informasi penting:

Tanda * menunjukkan commit dalam visualisasi riwayat.
HEAD -> main menunjukkan HEAD sedang berada pada branch main.
72e11af merupakan commit terbaru.
0ee624f merupakan commit pertama.

Perlu diperhatikan bahwa pada tahap ini repository belum dihubungkan ke remote. Karena itu, origin/main belum muncul pada output git log.

Untuk melihat ringkasan file pada commit pertama:

git show --stat 0ee624f

Output:

 .gitignore |  26 ++++++++++++++++
 README.md  |  47 ++++++++++++++++++++++++++++
 index.html | 101 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 174 insertions(+)

Output tersebut menunjukkan file yang berubah atau dibuat oleh commit 0ee624f. Pada commit kedua, hanya index.html yang berubah.

🔗 Repository Lokal dan GitHub

Repository lokal sekarang sudah memiliki dua commit. Namun, pada tahap ini seluruh riwayat tersebut masih berada di komputer lokal.

Untuk menyimpan repository pada server dan memudahkan kolaborasi, repository lokal dapat dihubungkan dengan GitHub.

Buat repository baru di GitHub dengan konfigurasi yang sesuai:

Repository name: devops-git-demo
Visibility: Private
Jangan membuat README tambahan dari GitHub.
Jangan membuat .gitignore tambahan dari GitHub.
Jangan menambahkan license dari GitHub untuk praktik ini.

Ketiga file tersebut sudah tersedia di repository lokal.

Setelah repository GitHub dibuat, tambahkan remote:

git remote add origin [email protected]:Maulana-Devops/devops-git-demo.git

Kemudian periksa:

git remote -v

Output:

origin	[email protected]:Maulana-Devops/devops-git-demo.git (fetch)
origin	[email protected]:Maulana-Devops/devops-git-demo.git (push)

git remote -v menunjukkan repository lokal telah memiliki remote bernama origin.

origin merupakan nama yang umum digunakan untuk remote utama. Nama tersebut sebenarnya dapat diganti dengan nama lain.

Dua jenis URL pada output tersebut memiliki fungsi berbeda:

fetch digunakan ketika mengambil data dari remote.
push digunakan ketika mengirim data ke remote.

Pada praktik ini digunakan SSH:

[email protected]:Maulana-Devops/devops-git-demo.git

Autentikasi SSH juga diperiksa menggunakan:

ssh -T [email protected]

Pemeriksaan tersebut digunakan untuk memastikan autentikasi SSH ke GitHub tersedia. Pemeriksaan ini tidak melakukan push dan tidak mengubah repository.

📤 Push Project ke GitHub

Setelah remote terhubung, commit lokal selanjutnya dapat dikirim ke GitHub menggunakan:

git push -u origin main

Struktur perintah tersebut adalah:

push → mengirim perubahan ke remote.
origin → nama remote.
main → branch yang dikirim.
-u → menetapkan hubungan upstream antara branch lokal dan remote.

Setelah upstream tersedia, push berikutnya dapat dilakukan dengan perintah yang lebih singkat:

git push

Push pada praktik ini berhasil dilakukan.

Untuk memeriksa kondisi repository lokal:

git status

Output:

On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean

Pesan tersebut menunjukkan branch lokal sudah sinkron menurut informasi tracking yang tersedia.

Namun, untuk verifikasi yang lebih langsung terhadap remote, digunakan:

git ls-remote origin

Hasilnya:

72e11afb0db258df0fa73b2e0a7cbbbf29bbe952	HEAD
72e11afb0db258df0fa73b2e0a7cbbbf29bbe952	refs/heads/main

Hash lokal kemudian dibandingkan dengan hash pada GitHub:

HEAD lokal     : 72e11afb0db258df0fa73b2e0a7cbbbf29bbe952
main di GitHub : 72e11afb0db258df0fa73b2e0a7cbbbf29bbe952

Keduanya identik.

Verifikasi tersebut memberikan bukti bahwa referensi main pada remote menunjuk ke commit yang sama dengan HEAD lokal.

Repository GitHub setelah project lokal berhasil dikirim melalui git push.

💡 Git dalam Workflow DevOps

Setelah memahami praktik dasar Git, selanjutnya kita dapat melihat mengapa version control memiliki posisi penting dalam DevOps.

Secara sederhana, workflow dapat digambarkan seperti ini:

Ilustrasi alur CI/CD — bukan output perintah terminal.

Developer → Git → Remote Repository → CI Server → Production
              commit       GitHub        test/build      deploy

Dalam workflow CI/CD, perubahan pada repository dapat menjadi pemicu untuk proses otomatis.

Secara umum alurnya dapat berupa:

Trigger — sistem mendeteksi perubahan baru pada repository.
Test — kode diuji secara otomatis.
Build — aplikasi dikemas atau dipersiapkan untuk dijalankan.
Deploy — hasil build dikirim ke lingkungan tujuan.

Git sendiri tidak menjalankan semua proses tersebut.

Perannya adalah menyediakan source control dan riwayat perubahan yang menjadi sumber informasi bagi sistem CI/CD.

Inilah salah satu hubungan utama antara Git dalam DevOps dan CI/CD.

Pada praktik yang dilakukan dalam artikel ini, project belum memiliki pipeline CI/CD. Jadi, kita belum menjalankan GitHub Actions, proses build otomatis, ataupun deployment.

Namun, fondasinya sudah terlihat: developer membuat perubahan, mencatatnya sebagai commit, kemudian mengirim commit tersebut ke remote repository.

Dari repository tersebut, sistem CI/CD dapat mengambil perubahan untuk diproses lebih lanjut.

Selain CI/CD, Git juga mendukung:

Traceability — perubahan dapat ditelusuri melalui riwayat commit.
Collaboration — pekerjaan dapat dilakukan melalui branch dan kemudian digabungkan.
Rollback — kondisi project dapat ditelusuri kembali ke commit sebelumnya ketika diperlukan.

🎯 Temuan Penting pada `.gitignore`

Selain mempraktikkan perintah dasar Git, ada satu temuan menarik pada project ini: pola .gitignore tidak selalu bekerja seperti asumsi awal.

.gitignore digunakan untuk memberi tahu Git file atau folder mana yang tidak perlu dilacak.

File yang biasanya diabaikan antara lain:

file sementara;
file hasil build;
dependency tertentu;
file konfigurasi lokal;
file yang berisi informasi sensitif.

Pada project ini, .gitignore mencakup pola .env dan .env.local, dengan komentar agar credential tidak dimasukkan ke repository.

Kemudian dilakukan pengujian menggunakan delapan file sementara.

File uji	Hasil
`.DS_Store`	Diabaikan
`Thumbs.db`	Diabaikan
`test.log`	Diabaikan
`temp.tmp`	Diabaikan
`node_modules/a.js`	Diabaikan
`dist/b.js`	Diabaikan
`secret.env`	Tidak diabaikan
`app.env`	Tidak diabaikan

Hasil yang lebih spesifik:

TERABAIKAN      : .env
TIDAK DIABAIKAN : secret.env
TIDAK DIABAIKAN : app.env
TERABAIKAN      : .env.local

Mengapa bisa terjadi?

Karena pola:

.env

mencocokkan nama .env, bukan seluruh file yang memiliki akhiran .env.

Sementara:

*.env

dapat mencocokkan nama seperti:

secret.env
app.env
config.env

Perbandingannya:

Pola	Contoh yang cocok
`.env`	`.env`
`*.env`	`secret.env`, `app.env`, `config.env`

Ini merupakan temuan nyata dari pengujian project, bukan sekadar asumsi.

Komentar pada .gitignore yang menyatakan agar credential tidak di-commit belum otomatis berarti seluruh file credential dengan pola nama tertentu akan terabaikan.

Jika project memang menggunakan banyak file dengan ekstensi .env, pola yang lebih sesuai dapat berupa:

*.env

Setelah pengujian selesai, file-file sementara tersebut dihapus kembali. Repository kembali berada pada kondisi clean.

Pelajaran penting dari pengujian ini adalah:

Konfigurasi sebaiknya diuji, bukan hanya diasumsikan sudah benar.

⚠️ Kesalahan yang Sering Dilakukan Pemula

Lupa Menjalankan `git add`

Perubahan file dapat berada di working directory tetapi belum masuk staging area.

Gunakan:

git status

untuk mengetahui apakah perubahan sudah di-stage atau belum.

Menggunakan Pesan Commit yang Tidak Jelas

Pesan seperti:

update

tidak memberikan banyak informasi ketika dibaca beberapa bulan kemudian.

Gunakan pesan yang menjelaskan perubahan secara spesifik, misalnya:

docs: tambah daftar materi dan naikkan revisi halaman ke 2

Tidak Memeriksa `git status`

git status merupakan perintah sederhana tetapi sangat berguna. Biasakan menjalankannya sebelum membuat commit agar mengetahui file mana yang akan masuk ke commit.

Salah Memahami Branch

Branch bukan folder dan bukan sekadar salinan file.

Branch merupakan penunjuk yang digunakan Git untuk mengelola jalur perkembangan commit.

Menganggap Remote Repository Sama dengan Backup

Remote repository membantu menyimpan dan berbagi repository di server, tetapi jangan otomatis menganggapnya sebagai sistem backup.

Backup seharusnya memiliki strategi, jadwal, dan mekanisme pemulihan yang sesuai kebutuhan.

Tidak Memahami Pola `.gitignore`

Temuan sebelumnya menunjukkan bahwa pola:

.env

tidak otomatis mencakup:

secret.env
app.env

Karena itu, aturan .gitignore perlu dipahami dan diuji.

⭐ Tips dan Best Practice Git

Beberapa kebiasaan yang dapat diterapkan sejak belajar Git:

Buat commit kecil dan fokus. Satu commit sebaiknya memiliki tujuan yang jelas.
Periksa git status sebelum commit. Langkah ini membantu mencegah file yang tidak diinginkan ikut masuk.
Gunakan pesan commit yang deskriptif. Riwayat akan lebih mudah dipahami.
Gunakan branch untuk pekerjaan yang terpisah. Hindari memasukkan perubahan besar langsung ke branch utama.
Jangan memasukkan credential ke repository. Gunakan .gitignore sebagai salah satu lapisan pencegahan.
Uji aturan .gitignore. Jangan hanya melihat konfigurasi dan menganggapnya sudah benar.
Gunakan remote repository untuk kolaborasi. Remote bukan sekadar tempat untuk menyimpan salinan project.
Verifikasi push bila diperlukan. git ls-remote dapat digunakan untuk melihat referensi pada remote tanpa mengubah repository.

🔗 Hubungan Git dengan CI/CD

Artikel ini merupakan bagian dari pembelajaran DevOps. Setelah memahami Git, materi berikutnya dapat dikembangkan secara bertahap.

Beberapa topik yang berkaitan adalah:

GitHub — repository, Issues, Pull Request, dan kolaborasi.
CI/CD — otomatisasi proses build, test, dan deployment.
GitHub Actions — automation workflow yang berjalan pada platform GitHub.
Docker — teknologi untuk mengemas aplikasi dan dependensinya.

GitHub Repositories Documentation

Continuous Deployment — GitHub Docs

Understanding GitHub Actions — GitHub Docs

Urutan pembelajaran tersebut penting. Git merupakan fondasi source control, sehingga memahami repository, commit, branch, dan remote akan membantu ketika mulai mempelajari pipeline CI/CD.

📁 Dokumentasi Project

Project yang digunakan dalam praktik adalah:

devops-git-demo/
├── .git/
├── README.md
├── index.html
└── .gitignore

Repository tersebut memiliki:

2 commit
- 0ee624f — commit pertama dengan 3 file dan 174 baris ditambahkan.
- 72e11af — perubahan kedua pada index.html.
Branch: main
Working tree: clean
Remote: origin
Remote repository: [email protected]:Maulana-Devops/devops-git-demo.git
Autentikasi: SSH
Tracking: main terhubung dengan origin/main
Verifikasi remote: hash HEAD lokal dan main pada GitHub identik.

Project ini menjadi contoh sederhana bagaimana repository lokal dapat berkembang dari folder biasa menjadi repository Git yang memiliki riwayat dan remote repository.

Dokumentasi praktik juga menunjukkan bahwa hasil tidak hanya diperiksa melalui git status, tetapi diverifikasi lebih lanjut menggunakan:

git ls-remote origin

Hasil verifikasi menunjukkan hash lokal dan remote sama:

HEAD lokal     : 72e11afb0db258df0fa73b2e0a7cbbbf29bbe952
main di GitHub : 72e11afb0db258df0fa73b2e0a7cbbbf29bbe952

🧪 Mini Practice

Setelah memahami praktik di atas, coba ulangi pada repository milik sendiri.

Jangan menggunakan repository orang lain untuk latihan pertama.

Mulai dengan:

mkdir repo-latihan && cd repo-latihan
git init -b main

Kemudian lakukan latihan berikut:

Buat satu file sederhana.
Jalankan git status dan perhatikan status file.
Ubah isi file tersebut.
Jalankan git diff dan perhatikan baris + dan -.
Jalankan git add.
Jalankan git status kembali dan lihat perubahan statusnya.
Buat commit dengan pesan yang jelas.
Lakukan perubahan kedua.
Buat commit kedua.
Jalankan:

git log --oneline

Perhatikan berapa commit yang terbentuk.

Setelah selesai, catat tiga hal:

berapa commit yang terbentuk;
file apa saja yang masuk ke setiap commit;
bagaimana perubahan git status sebelum dan sesudah git add.

Latihan sederhana tersebut akan membantu memahami konsep working directory, staging area, commit, dan repository secara langsung.

Kesimpulan

Version control menjawab satu masalah penting dalam pengembangan software: bagaimana mencatat dan mengelola perubahan dari waktu ke waktu.

Git dalam DevOps menyediakan mekanisme tersebut melalui repository, commit, branch, dan remote. Dengan Git, perubahan tidak hanya disimpan sebagai file terbaru, tetapi menjadi bagian dari riwayat yang dapat ditelusuri.

Praktik pada artikel ini memperlihatkan proses tersebut dari awal.

git init digunakan untuk membuat repository. git status digunakan untuk memeriksa kondisi file. git add memasukkan perubahan ke staging area. git commit mencatat perubahan sebagai bagian dari riwayat. git diff memperlihatkan perbedaan antarversi. Kemudian git log digunakan untuk melihat riwayat commit.

Repository tersebut kemudian dihubungkan dengan GitHub menggunakan remote origin dan dikirim menggunakan git push.

Hasil push tidak hanya dilihat dari repository GitHub, tetapi juga diverifikasi menggunakan git ls-remote. Hash lokal dan hash branch main pada remote menunjukkan nilai yang sama:

72e11afb0db258df0fa73b2e0a7cbbbf29bbe952

Praktik tersebut juga menghasilkan satu temuan penting pada .gitignore. Pola .env tidak otomatis mencakup file seperti secret.env dan app.env. Artinya, konfigurasi yang terlihat benar tetap perlu diuji.

Hal yang sama berlaku pada workflow DevOps secara keseluruhan. Git sendiri bukan CI/CD, tetapi Git menjadi fondasi source control yang dapat menjadi sumber perubahan untuk proses otomatis seperti testing, build, dan deployment.

Setelah memahami Git, langkah berikutnya adalah mempelajari GitHub secara lebih mendalam, kemudian melanjutkan ke CI/CD dan GitHub Actions.

📚 Referensi

Git Documentation — https://git-scm.com/documentation
Pro Git Book — https://git-scm.com/book/en/v2
Git Reference Manual — https://git-scm.com/docs
GitHub Docs — https://docs.github.com

Mau Kuasai Mengenal Git dalam DevOps: Mengapa Version Control Penting? Sampai Bisa Praktik Langsung?

Materi ini juga kami ajarkan langsung di kelas Edusoft Center, dibimbing mentor, sampai kamu bisa praktik nyata — bukan cuma baca teori.

Tanya Kursus via WhatsApp Lihat contoh project nyata dari siswa kami →

Mengenal Git dalam DevOps: Mengapa Version Control Penting?

Pendahuluan

📘 Apa yang Akan Dipelajari?

❓ Mengapa Git Penting dalam DevOps?

📖 Apa Itu Version Control?

📖 Apa Itu Git?

📦 Repository, Commit, Branch, dan Remote

Repository

Commit

Branch

Remote

⚙️ Bagaimana Git Bekerja?

Working Directory

Staging Area

Repository

💻 Persiapan Praktik

📌 Praktik Git pada Project

Kondisi Project Sebelum Git

Membuat Repository dengan git init

Memeriksa Status dengan git status

Memasukkan File ke Staging Area

Membuat Commit Pertama

Melakukan Perubahan pada Project

Melihat Perubahan dengan git diff

Membuat Commit Kedua

Melihat Riwayat dengan git log

🔗 Repository Lokal dan GitHub

📤 Push Project ke GitHub

💡 Git dalam Workflow DevOps

🎯 Temuan Penting pada .gitignore

⚠️ Kesalahan yang Sering Dilakukan Pemula

Lupa Menjalankan git add

Menggunakan Pesan Commit yang Tidak Jelas

Tidak Memeriksa git status

Salah Memahami Branch

Menganggap Remote Repository Sama dengan Backup

Tidak Memahami Pola .gitignore

⭐ Tips dan Best Practice Git

🔗 Hubungan Git dengan CI/CD

📁 Dokumentasi Project

🧪 Mini Practice

Kesimpulan

📚 Referensi

Post comment

Cancel reply

Membuat Repository dengan `git init`

Memeriksa Status dengan `git status`

Melihat Perubahan dengan `git diff`

Melihat Riwayat dengan `git log`

🎯 Temuan Penting pada `.gitignore`

Lupa Menjalankan `git add`

Tidak Memeriksa `git status`

Tidak Memahami Pola `.gitignore`