Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Git, DevOps & ToolingJunior16 phút đọc

Git: remote, clone, tag phiên bản và thói quen push hằng ngày

Ôn 13 thẻ
Trong bài này

Cụm bài Git: 1. Commit và object model · 2. Remote, tag và backup · 3. Branching, merge, rebase và PR

Phần 1 nói về những gì xảy ra trên máy bạn: ba vùng của Git, object model và cách viết commit. Phần này đưa repo ra khỏi máy: push lên GitHub, clone sang máy khác, biết chính xác phần nào chưa được backup, rồi đánh số phiên bản bằng Semantic Versioning và tag. Nên đọc phần 1 trước, nhất là mục commit convention, vì cách đánh số phiên bản ở cuối bài dựa trên nó.

Sơ đồ tóm tắt:

flowchart LR
  W[Thư mục làm việc] -->|commit| L[Repo local]
  L -->|push| R["Remote (GitHub)"]
  R -->|"fetch / pull"| L
  R -->|"clone (máy mới)"| L
  ST["Stash, nhánh chưa push, file ignore"] -.->|chỉ trên máy| W
  L -->|annotated tag| TG["Tag: SemVer MAJOR.MINOR.PATCH"]
  TG -->|"phải push tag riêng"| R

1. GitHub và remote

Ý chính: remote là một bản repo nằm ở máy khác (thường là GitHub) để code không chết theo laptop và chia sẻ được. Gắn bằng git remote add, đẩy bằng git push, lấy về bằng git fetch/git pull.

GitHub là nền tảng lưu trữ và chia sẻ Git repo (cùng loại: GitLab, Bitbucket, Gitea).

# 1. Tạo repo trống trên GitHub (qua web hoặc: gh repo create booking-service --private)
# 2. Gắn remote
git remote add origin git@github.com:<user>/booking-service.git
git remote -v
# 3. Đẩy branch lên, -u để lần sau chỉ cần "git push"
git push -u origin main
# Lấy thay đổi của người khác
git fetch origin            # chỉ tải về, không đụng code của bạn
git pull --rebase origin main

git pull = git fetch + git merge (hoặc rebase nếu cấu hình pull.rebase=true). Senior hay fetch trước để xem có gì mới, rồi mới quyết định tích hợp thế nào.

Clone: đưa repo sang một máy mới

Ý chính: git clone <url> tạo bản sao đầy đủ của repo (cả lịch sử) trên máy chưa có repo. Clone một lần, sau đó chỉ fetch/pull.

Slide GitHub có hai hình: máy thứ nhất push lịch sử lên GitHub, rồi một laptop khác tải về đúng lịch sử đó bằng git clone.

git clone git@github.com:<user>/booking-service.git           # tạo thư mục booking-service
git clone git@github.com:<user>/booking-service.git my-dir    # đặt tên thư mục khác
git clone -b develop git@github.com:<user>/booking-service.git # checkout sẵn nhánh develop
Lệnh Dùng khi Làm gì
git clone <url> Máy chưa có repo Tạo repo mới, một lần duy nhất
git fetch Đã có repo Tải commit mới, chỉ cập nhật origin/*
git pull Đã có repo fetch + tích hợp vào nhánh hiện tại

Clone lại mỗi lần muốn cập nhật là phí thời gian, và mất các nhánh, stash chưa push trên bản cũ.

git clone làm gì bên trong, và shallow clone trong CI

git clone làm một lúc nhiều việc:

  1. Tạo thư mục và chạy git init.
  2. Thêm remote tên origin trỏ tới URL.
  3. Tải toàn bộ object và lịch sử.
  4. Tạo các remote-tracking branch (origin/main, origin/develop…) — bản ghi “remote đang ở đâu” lúc fetch gần nhất.
  5. Tạo nhánh local main theo dõi origin/main và checkout nó.

Các nhánh khác chưa có bản local, nhưng git switch develop sẽ tự tạo nhánh local theo dõi origin/develop.

2. Thói quen hằng ngày: commit, push và Git như một bản backup

Ý chính: làm xong mỗi bài (hay mỗi phần việc) thì commit và push ngay. Vừa luyện tay, vừa luôn có bản sao code nằm ngoài máy.

  1. Luyện tay. add, commit, push mỗi ngày sẽ thành phản xạ. Đi thực tập hay đi làm, người ta mặc định bạn đã biết Git.
  2. Bản sao ngoài máy. Laptop hỏng, mất, chết ổ cứng: git clone trên máy khác là làm tiếp.

Cài đặt một lần cho máy mới

Ý chính: đặt tên, email, nhánh mặc định, gitignore toàn cục và SSH key một lần cho mỗi máy.

git config --global user.name  "Nguyen Van A"
git config --global user.email "a@example.com"       # trùng email tài khoản GitHub để commit được gắn đúng người
git config --global init.defaultBranch main
git config --global pull.rebase true                 # pull = fetch + rebase cho nhánh cá nhân
git config --global core.excludesFile ~/.gitignore_global   # file rác của OS/IDE, không phải của dự án

ssh-keygen -t ed25519 -C "a@example.com"             # tạo SSH key, dán ~/.ssh/id_ed25519.pub vào GitHub
ssh -T git@github.com                                # kiểm tra kết nối
  • .gitignore của dự án: thứ dự án sinh ra (target/, build/, .env).
  • Gitignore toàn cục: rác của máy bạn (.DS_Store, .idea/, *.iml), khỏi lặp lại ở mọi repo.

Git là backup, nhưng chỉ cho những gì đã commit và đã push

Ý chính: “đẩy lên Git là có backup” chỉ đúng một phần. Năm thứ dưới đây không nằm trên remote.

Thứ Vì sao không được backup Cách xử lý
Thay đổi chưa commit, file chưa git add Chỉ nằm trong working directory Commit sớm, kể cả commit “wip” trên nhánh của mình
Commit chưa push Chỉ nằm trong repo trên máy git status -sb hiện [ahead 2]; push cuối mỗi buổi
Nhánh local chưa từng push git push không tự đẩy nhánh chưa có upstream git push -u origin <nhánh> ngay khi tạo nhánh
git stash Stash chỉ tồn tại trên máy Đừng dùng stash làm chỗ cất đồ lâu dài; commit lên một nhánh
File bị ignore (.env, DB local, dữ liệu test lớn) Cố ý không đưa vào Git Secret để trong password manager hoặc secret manager; dữ liệu thì có script sinh lại
git status -sb                       # ## main...origin/main [ahead 2]  -> còn 2 commit chưa push
git log --oneline origin/main..main  # liệt kê đúng các commit chưa có trên remote
git branch -vv                       # nhánh nào theo dõi remote nào, nhánh nào chưa có upstream

Với code công ty, “đã push lên GitHub” chưa phải chính sách backup. Remote cũng mất được: xoá nhầm repo, tài khoản bị khoá, ai đó force push đè lịch sử. Tổ chức thường bật branch protection (cấm force push vào nhánh chính) và mirror định kỳ sang nơi khác.

Backup cấp tổ chức: mirror và git bundle
git clone --mirror git@github.com:acme/booking-service.git   # bản sao đầy đủ mọi ref
git -C booking-service.git remote update --prune             # chạy định kỳ (cron) để cập nhật
git bundle create booking-2026-11-17.bundle --all            # đóng gói cả repo thành một file
git clone booking-2026-11-17.bundle restored                 # khôi phục từ file bundle

Hai lưu ý nữa:

  • Đừng commit file lớn và file sinh ra (.jar, target/, video, dump database). Git giữ mọi phiên bản mãi mãi, nên repo phình và ai clone cũng tải hết. File nhị phân lớn cần quản lý phiên bản thì dùng Git LFS.
  • Commit “wip” trên nhánh của mình là bình thường. Mục tiêu là không mất việc; trước khi mở Pull Request thì dọn bằng interactive rebase (xem phần 3).

3. Số phiên bản (Semantic Versioning) và tag

Ý chính: SemVer đọc số phiên bản MAJOR.MINOR.PATCH như một lời hứa về tương thích. Mỗi bản phát hành được đánh dấu bằng một tag: con trỏ cố định vào một commit.

Slide có hình dòng thời gian phát hành: vài bản 0.9.x beta, rồi 1.0.0, các bản vá 1.0.1…1.0.3, 1.1, 1.2.x, rồi nhảy lên 2.0.0.

Phần Tăng khi Ví dụ
MAJOR Có thay đổi phá vỡ tương thích (đổi/xoá API, đổi format dữ liệu) 1.4.2 → 2.0.0
MINOR Thêm tính năng mới mà vẫn tương thích ngược 1.4.2 → 1.5.0
PATCH Chỉ sửa bug, không đổi API 1.4.2 → 1.4.3
  • Tăng phần lớn thì reset phần nhỏ về 0 (1.4.2 → 2.0.0, không phải 2.4.2).
  • 0.y.z là chưa ổn định: API đổi lúc nào cũng được, nên bản 0.9 “beta” trên slide chưa hứa gì. 1.0.0 là cam kết API công khai đầu tiên.
  • Hậu tố pre-release (2.0.0-rc.1, 1.0.0-beta.2) xếp trước bản chính thức tương ứng.

Liên hệ Conventional Commits ở phần 1: fix → PATCH, feat → MINOR, ! hoặc BREAKING CHANGE: → MAJOR. Tool như semantic-release đọc lịch sử commit rồi tự chọn số tiếp theo. Trong pipeline, Git tag v1.4.0 thành tag SemVer của image và kích hoạt release: xem CI/CD cho backend.

Tag khác branch ở chỗ nó không tự di chuyển khi có commit mới.

git tag -a v1.2.0 -m "Release 1.2.0: hotel search by price"   # annotated tag
git tag                                  # liệt kê tag
git show v1.2.0                          # người tạo, ngày, message, commit được tag
git push origin v1.2.0                   # đẩy riêng một tag
git push --follow-tags                   # đẩy commit kèm các annotated tag trỏ vào chúng
git checkout v1.2.0                      # xem code đúng bản đã phát hành (detached HEAD)
git describe                             # v1.2.0-3-g8a6504e: bản đang đứng cách tag gần nhất 3 commit

Bài tập

Bài 1 — Repo học tập với thói quen “học xong là push”

Đề (diễn đạt lại): Tạo một repo trên GitHub (hoặc GitLab) cho code của khoá học. Học xong mỗi bài thì commit code của bài đó và push lên remote. Mục đích kép: luyện lệnh Git hằng ngày và luôn có bản sao code nằm ngoài máy.

Lời giải Bài 1: tạo repo, push mỗi bài, diễn tập khôi phục
mkdir java-core-notes && cd java-core-notes
git init
cat > .gitignore <<'EOF'
target/
out/
*.class
.env
EOF
echo "# Java Core - code theo từng bài" > README.md
git add .gitignore README.md
git commit -m "chore: init repository"
gh repo create java-core-notes --private --source=. --remote=origin --push

# --- Sau mỗi bài học ---
mkdir -p lesson15-hello-world   # viết HelloWorld.java vào đây
git add lesson15-hello-world
git commit -m "feat(lesson15): print hello world and compile with javac"
git push

# --- Cuối ngày: kiểm tra không còn gì chỉ nằm trên máy ---
git status -sb                        # không có [ahead N], không có file lạ
git log --oneline origin/main..main   # rỗng nghĩa là đã push hết

# --- Diễn tập "mất laptop": clone sang thư mục khác và chạy thử ---
git clone git@github.com:<user>/java-core-notes.git /tmp/restore-test
java /tmp/restore-test/lesson15-hello-world/HelloWorld.java
  • .gitignore có từ commit đầu nên file .class và .env không lọt lên.
  • Mỗi bài một commit theo Conventional Commits (feat(lesson15): ...), nhìn git log --oneline là thấy tiến độ.
  • Diễn tập khôi phục quan trọng hơn ta nghĩ: backup chưa từng khôi phục thử thì chưa chắc dùng được.

Senior làm thêm:

  • Alias kiểm tra trước khi tắt máy: git config --global alias.unpushed "log --branches --not --remotes --oneline" — liệt kê commit chưa push trên mọi nhánh, không chỉ nhánh hiện tại.
  • Pre-commit hook quét secret (gitleaks) để không bao giờ push nhầm .env.
  • git push --all origin nếu repo có nhiều nhánh bài tập.

Ghi nhớ

  • Giải thích được clone, fetch, pull khác nhau thế nào và khi nào dùng cái nào.
  • Kể được năm thứ “đã push lên GitHub” vẫn không backup, và lệnh để kiểm tra còn gì chưa push.
  • Biết vì sao .gitignore không gỡ file đã commit và phải làm gì khi lỡ commit secret.
  • Đọc được một số SemVer và nối được fix/feat/! với phần tăng tương ứng.
  • Biết chọn annotated tag cho release, cách đẩy tag, và vì sao không dời tag đã công bố.

Câu hỏi phỏng vấn

Junior

git fetch và git pull khác nhau thế nào?

fetch chỉ tải về, pull tải về rồi tích hợp vào nhánh hiện tại.

fetch cập nhật các remote-tracking branch (origin/main), không đụng branch và file của bạn. pull = fetch + merge (hoặc rebase nếu dùng --rebase).

.gitignore đã có dòng .env nhưng Git vẫn báo file .env thay đổi. Vì sao, sửa thế nào?

.gitignore chỉ áp dụng cho file chưa được theo dõi; .env đã từng được commit nên Git vẫn theo dõi.

Gỡ khỏi index bằng git rm --cached .env rồi commit; file trên đĩa vẫn còn. Nếu .env chứa secret thì secret đã nằm trong lịch sử, phải đổi (rotate) ngay.

git clone khác git pull thế nào?

clone dùng một lần cho máy chưa có repo; pull dùng khi đã có repo để lấy commit mới.

clone tạo thư mục, thêm remote origin, tải toàn bộ lịch sử và checkout nhánh mặc định. pull fetch commit mới của remote và tích hợp vào nhánh đang đứng.

Đọc số phiên bản 2.3.1 thế nào theo Semantic Versioning?

MAJOR.MINOR.PATCH: 2 là major (phá tương thích), 3 là minor (tính năng mới, tương thích ngược), 1 là patch (chỉ sửa bug).

Lên 2.4.0 là có tính năng mới, nâng cấp an toàn; lên 3.0.0 thì phải đọc changelog vì có breaking change. Bản 0.x được coi là chưa ổn định.

Mid

Push code lên GitHub mỗi ngày đã đủ làm backup chưa?

Chỉ đủ cho những gì đã commit và đã push.

  • Thay đổi chưa commit, commit chưa push, nhánh local chưa có upstream, stash và file bị ignore đều chỉ nằm trên máy. git status -sb và git log --branches --not --remotes cho biết còn gì chưa đẩy.
  • Với code tổ chức, remote cũng mất được (xoá nhầm repo, force push đè lịch sử): cần branch protection, mirror định kỳ hoặc git bundle sang nơi khác, và thỉnh thoảng thử khôi phục thật.
Annotated tag và lightweight tag khác nhau ra sao, release nên dùng loại nào?

Release dùng annotated tag: một object riêng có người tạo, ngày, message, có thể ký GPG; lightweight chỉ là một ref trỏ vào commit.

Annotated cho thông tin truy vết, và git describe, git push --follow-tags mặc định chỉ dùng annotated tag. Nhớ: git push thường không đẩy tag, và đừng dời tag đã công bố sang commit khác, hãy ra bản patch mới.

Senior

Bạn sẽ tự động hoá việc phát hành version từ lịch sử commit thế nào, và chỗ nào dễ sai?

Ép Conventional Commits trong CI, rồi để semantic-release hoặc release-please tính version, sinh changelog và tạo annotated tag trên nhánh chính.

Tool đọc commit từ tag gần nhất, tính version tiếp theo theo SemVer, sinh changelog, tạo annotated tag và build artifact đúng từ commit đó. commitlint trong CI ép convention. Dễ sai ở:

  • Job CI dùng shallow clone nên không thấy tag cũ (cần fetch-depth: 0).
  • Squash merge làm mất type của từng commit nếu tiêu đề PR không theo convention.
  • Ai đó xoá rồi tạo lại tag, cùng một version trỏ tới hai commit (bật protected tags, coi tag là bất biến).
  • Breaking change không đánh dấu ! nên chỉ tăng minor.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
remote /rɪˈmoʊt/ repo ở xa (GitHub, GitLab) “I push to the remote at the end of every session, so nothing lives only on my laptop.”
upstream branch /ˈʌp.striːm bræntʃ/ nhánh trên remote mà nhánh local theo dõi “git push -u sets the upstream branch, so later a plain git push is enough.”
untrack /ʌnˈtræk/ ngừng theo dõi file “I had to untrack the config file with git rm --cached.”
backup /ˈbæk.ʌp/ bản sao dự phòng “A backup you’ve never restored is just a hope.”
clone /kloʊn/ sao chép cả repo về máy “On a new laptop I just clone the repo and keep working.”
shallow clone /ˈʃæl.oʊ kloʊn/ clone chỉ lấy commit gần nhất “Our CI uses a shallow clone, except for the release job, which needs the full history.”
tag /tæɡ/ nhãn cố định trỏ vào một commit “Every release is an annotated tag, so we can check out exactly what shipped.”
semantic versioning /sɪˈmæn.tɪk ˈvɜː.ʒən.ɪŋ/ đánh số phiên bản MAJOR.MINOR.PATCH “Under semantic versioning, a breaking change bumps the major version.”
backward compatible /ˈbæk.wərd kəmˈpæt.ə.bəl/ tương thích ngược “A minor release must stay backward compatible.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer) và tài liệu Java Core của Hỏi Dân IT, cộng thêm kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.