CI/CD-இல் build automation என்றால் என்ன?

Question

Accepted Answer

**Build automation** என்பது **কম্பাইলிং, প্যাকেজிং, மற்றும் தயாரிப்பு** செயல்முறையை தானாக மேற்கொண்டு, குறிப்பு மேல் முறைகள் இல்லாமல் குறியீட்டை பயன்பாட்டுக்குத் தகுந்த பொருட்களாக மாற்றுவது. இது CI/CD pipeline-ன் முதல் முக்கிய நிலை, மூல குறியீட்டை சோதித்து பயன்படுத்த முடியுமான ஏதாவது ஆக மாற்றுகிறது.

## Build நிலை என்ன செய்கிறது

```text
The BUILD automates turning source code into a deployable ARTIFACT:
  → INSTALL dependencies (npm install, pip install, etc.)
  → COMPILE / transpile code (if needed: Java, TypeScript, Go, etc.)
  → BUNDLE / package (frontend bundles, JARs, binaries)
  → BUILD container images (Docker) if containerized
  → produce ARTIFACTS ready for testing and deployment
→ Automated, consistent, repeatable — no manual build steps.
```

## Build-ஐ ஏன் தானாக்க வேண்டும்?

```text
✓ CONSISTENCY — the same build process every time (no "works on my machine" build issues)
✓ REPEATABILITY — anyone/any pipeline can reproduce the build identically
✓ SPEED — automated builds are fast and don't require manual effort
✓ EARLY ERROR DETECTION — build failures (compile errors, missing deps) caught immediately
✓ Foundation for the rest of the pipeline (test/deploy need the build output)
```

## Artifacts மற்றும் reproducibility

```text
→ The build produces ARTIFACTS (a Docker image, a JAR, a bundle) — versioned and stored
  (in a registry/artifact repository)
→ Build the artifact ONCE, then deploy that SAME artifact through environments
  (staging → prod) → ensures what you tested is what you deploy
→ Reproducible builds: pin dependency versions; same inputs → same output
```

## இது ஏன் முக்கியமானது

Build automation-ஐ புரிந்துகொள்வது மதிப்புவாய்ந்தது என்பதால் இது CI/CD-ன் ஒரு அடிப்படை நிலை — மூல குறியீட்டை பயன்பாட்டுக்குத் தகுந்த பொருட்களாக மாற்றும் அஸ்திவாரம் — எனவே இது பயனுள்ள நடைமுறை அறிவு.

Build நிலை **குறியீட்டை compilation, packaging, மற்றும் தயாரிப்பு செய்வதை தானாக்குகிறது** (dependencies நிறுவல், compiling, bundling, container images உருவாக்கல்) பயன்பாட்டுக்குத் தகுந்த **artifacts**-ஆக, தனிப்பட்ட படிகள் இல்லாமல்.

**ஏன் தானாக்கல் முக்கியம்** என்பதை புரிந்துகொள்வது முக்கியம்: இது **consistency** (ஒவ்வொரு முறையும் ஒரே build செயல்முறை, தனிப்பட்ட அல்லது வேறுபட்ட build சூழல்களிலிருந்து build-தொடர்பான "works on my machine" சிக்கல்களை தவிர்ப்பது), **repeatability** (எந்த pipeline-ம் build-ஐ ஒரே மாதிரியாக மீண்டும் உருவாக்குகிறது), **speed** (வேகமான, முயற்சி-இல்லாத builds), மற்றும் **early error detection** (compile பிழைகள் அல்லது காணாமல் போன dependencies போன்ற build தோல்விகள் உடனடியாக பிடிபடுகின்றன) — build-ஐ நம்பகமாக்கி pipeline-ன் மீதி பகுதிக்கான உறுதியான அடிப்படையை வழங்குகிறது (சோதனை மற்றும் deployment build output தேவைப்படுகிறது).

**artifact மற்றும் reproducibility** கருத்து — build பதிப்பிடப்பட்ட artifacts-ஐ ஒரு registry-ஆ உருவாக்குகிறது, மற்றும் **build ஒரு முறை மேற்கொண்டு அந்த ஒரே artifact-ஐ சூழல்களூடாக பயன்படுத்துவதன்** (staging பின்னர் production) சிறந்த நடைமுறை, இதனால் **நீங்கள் சோதித்தது சரியாக நீங்கள் பயன்படுத்துவது** (rebuilding-இலிருந்து மாற்றங்களை தவிர்ப்பது) — நம்பகமான வழங்கலின் முக்கிய கொள்கையை பிரதிபலிக்கிறது — என்பதை புரிந்துகொள்வது முக்கியம்.

Reproducible builds-பற்றி அறிந்துகொள்வது (ஒரு மாறாத செயல்பாட்டுக்கான dependency பதிப்புகளை핀் செய்வது) மதிப்புவாய்ந்தது.

Build automation CI/CD-ன் அடிப்படை முதல் நிலை என்பதால் (பிற எல்லாம் சார்பாக இருக்கும் artifacts உருவாக்குகிறது) மற்றும் அதை சரியாக பெறுவது (consistent, repeatable, build-once-deploy-everywhere) நம்பகமான வழங்கலுக்கு முக்கியம், build automation-பற்றி புரிந்துகொள்வது — build நிலை என்ன செய்கிறது, ஏன் தானாக்கல் முக்கியம், மற்றும் artifact/reproducibility கொள்கைகள் — மதிப்புவாய்ந்த, நடைமுறைக்கு பொருந்தக்கூடிய CI/CD அறிவு, pipeline-ன் ஒரு அடிப்படை பகுதி, குறியீடு சோதனை மற்றும் deployment-க்கு நம்பகமாக மற்றும் ஒரு மாறாக தயாரிக்கப்படுவதை உறுதிசெய்கிறது.