DevOps बूटकैंप · पाठ

गोपनीय जानकारी का सुरक्षित प्रबंधन और परिवेश की स्वच्छता

stdin, फ़ाइलों और साफ़ किए गए परिवेश का उपयोग करके क्रेडेंशियल को प्रोसेस सूची और लॉग से बाहर रखें।

पाठ 2, कुल 4 में से13 चरण

गोपनीय जानकारी का सुरक्षित प्रबंधन और परिवेश की स्वच्छता, CoddyKit पर DevOps बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह DevOps बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। DevOps बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

गुप्त जानकारी की स्वच्छता क्यों महत्वपूर्ण है

गुप्त जानकारी — API कुंजियाँ, पासवर्ड और टोकन — किसी भी प्रणाली का सबसे संवेदनशील डेटा होती है। Bash लिपियों में इसे गलत ढंग से संभालना सबसे आम और गंभीर सुरक्षा गलतियों में से एक है।

प्रक्रिया सूचियाँ: कमांड को दिए गए तर्क ps aux, /proc/<pid>/cmdline और सिस्टम ऑडिट लॉग में दिखाई देते हैं — होस्ट के सभी उपयोगकर्ताओं को दिख सकते हैं।
शेल इतिहास: इंटरैक्टिव रूप से टाइप किए गए कमांड (और कभी-कभी लिपियाँ) ~/.bash_history में दर्ज होते हैं।
लॉग फ़ाइलें: set -x के अनुरेख, अनुप्रयोग लॉग और CI/CD आउटपुट चर के मानों को दर्ज कर सकते हैं।
पर्यावरण का रिसाव: बाल प्रक्रियाएँ अपने जनक का पूरा पर्यावरण प्राप्त करती हैं, जिसमें निर्यात की गई कोई भी गुप्त जानकारी शामिल होती है।

सुदृढ़ लिपि गुप्त जानकारी को रेडियोधर्मी पदार्थ की तरह संभालती है — संपर्क का समय घटाती है, जोखिम की सतह सीमित करती है और बाहर भेजते समय हर चीज़ का स्वच्छीकरण करती है।

प्रक्रिया सूची के हमले की सतह

जब आप किसी गुप्त जानकारी को कमांड-लाइन तर्क के रूप में पास करते हैं, तो सिस्टम का हर उपयोगकर्ता ps के माध्यम से उसे तुरंत पढ़ सकता है। यह केवल सैद्धांतिक समस्या नहीं है — साझा होस्टिंग और कंटेनर परिवेशों में इसका नियमित रूप से दुरुपयोग होता है।

नीचे का अंश समस्या और उसके समाधान को साथ-साथ दिखाता है।

#!/usr/bin/env bash
# DANGEROUS: password visible in 'ps aux' output
# curl -u "admin:SuperSecret123" https://api.example.com/data

# SAFE: pass credentials via stdin or a flag that reads from a file
# Many tools support reading secrets from stdin with '-' or dedicated flags:

# Option 1 — pipe the secret so it never appears in argv
echo 'SuperSecret123' | curl -u 'admin' --password-stdin \
  https://api.example.com/data 2>/dev/null || true

# Option 2 — write a temporary netrc and point curl at it
# (covered in a later scene)
echo 'Secret never touches the command line this way'

मानक इनपुट से गुप्त जानकारी पढ़ना

सबसे सुरक्षित इंटरैक्टिव तरीका है कि read -rs का उपयोग करके चलते समय गुप्त जानकारी पढ़ी जाए। -s फ़्लैग प्रतिध्वनि को रोकता है, इसलिए वर्ण कभी प्रदर्शित नहीं होते, और -r बैकस्लैश की व्याख्या को रोकता है।

मुख्य बातें:

चर को कभी निर्यात नहीं किया जाता, इसलिए बाल प्रक्रियाएँ /proc/<pid>/environ के माध्यम से उसे नहीं देख सकतीं।
उपयोग के बाद संपर्क की अवधि घटाने के लिए चर को तुरंत unset करें।
echo "$SECRET" से बचें — मान को खराब करने वाली अंतिम नई पंक्ति रोकने और अनुरेखों में अदृश्य बने रहने के लिए printf '%s' का उपयोग करें।

#!/usr/bin/env bash
set -euo pipefail

# Prompt on stderr so stdout stays clean for piping
read -rsp 'Enter API token: ' API_TOKEN <&2
printf '\n' >&2

# Use the secret — printf keeps it out of argv
response=$(printf '%s' "$API_TOKEN" | curl -sS -X POST \
  -H 'Content-Type: application/json' \
  --data-binary @- \
  https://httpbin.org/post 2>/dev/null) || true

echo "Request sent."

# Scrub immediately — unset removes it from shell memory
unset API_TOKEN

फ़ाइलों में गुप्त जानकारी: अनुमतियाँ और स्वामित्व

जब कोई गुप्त जानकारी डिस्क पर स्थायी रूप से रखनी हो (जैसे किसी सेवा खाते की कुंजी), तो फ़ाइल की अनुमतियाँ आपकी पहली सुरक्षा पंक्ति होती हैं।

मोड 0600 — केवल स्वामी ही इसे पढ़ और लिख सकता है। समूह या अन्य किसी के लिए पहुँच नहीं होती।
मोड 0400 — स्वामी के लिए केवल-पठन। उन कुंजियों के लिए इसे प्राथमिकता दें जिन्हें आप कभी गलती से अधिलेखित नहीं करना चाहते।
गुप्त जानकारी वाली फ़ाइलों को ~/.secrets/ या /run/secrets/ जैसी समर्पित निर्देशिका में रखें (/run/secrets/ कई Linux प्रणालियों में RAM-आधारित tmpfs होता है और केवल पुनः-बूट होने तक रहता है)।
किसी git-ट्रैक की गई निर्देशिका में गुप्त जानकारी वाली फ़ाइलें कभी भी मज़बूत .gitignore के बिना न रखें।

#!/usr/bin/env bash
set -euo pipefail

SECRETS_DIR="${HOME}/.secrets"
mkdir -p "$SECRETS_DIR"
chmod 700 "$SECRETS_DIR"   # directory: only owner can list contents

KEY_FILE="${SECRETS_DIR}/api_token"

# Write secret — atomically restrict permissions before writing content
install -m 0600 /dev/null "$KEY_FILE"
printf '%s' 'my-super-secret-token' > "$KEY_FILE"

echo "Permissions:"
ls -la "$KEY_FILE"

# Read back safely — no subshell, no echo
API_TOKEN=$(< "$KEY_FILE")
echo "Token length: ${#API_TOKEN} chars (value not printed)"
unset API_TOKEN

curl के साथ .netrc फ़ाइल का उपयोग

curl एक ~/.netrc फ़ाइल (या --netrc-file के माध्यम से कोई भी मनमाना पथ) इस्तेमाल कर सकता है, जो होस्टनाम को प्रमाण-पत्रों से जोड़ती है। इससे प्रमाणीकरण संबंधी जानकारी आदेश-पंक्ति और स्क्रिप्ट के मुख्य भाग, दोनों से पूरी तरह बाहर रहती है।

फ़ाइल का प्रारूप सरल है:

machine api.example.com
  login admin
  password s3cr3t

सर्वोत्तम अभ्यास:

हमेशा chmod 0600 ~/.netrc सेट करें — कुछ प्रणालियों में सभी के लिए पठनीय होने पर curl इस फ़ाइल को अस्वीकार कर देता है।
tmpfs-आधारित या कंटेनर द्वारा डाली गई गुप्त जानकारी वाली फ़ाइल के लिए --netrc-file /run/secrets/netrc का उपयोग करें।
अस्थायी netrc फ़ाइलों को EXIT पर trap की सहायता से साफ़ करें।

#!/usr/bin/env bash
set -euo pipefail

TMP_NETRC=$(mktemp)
chmod 0600 "$TMP_NETRC"

# Trap ensures cleanup even on error or signal
trap 'rm -f "$TMP_NETRC"' EXIT

# Write credentials to the temp netrc
cat > "$TMP_NETRC" <<'EOF'
machine httpbin.org
  login myuser
  password mypassword
EOF

curl -fsS --netrc-file "$TMP_NETRC" \
  https://httpbin.org/basic-auth/myuser/mypassword \
  -o /dev/null -w 'HTTP %{http_code}\n' || true

# trap fires here: $TMP_NETRC is deleted
echo 'Temp netrc cleaned up by trap.'

पर्यावरण चरों की स्वच्छता

पर्यावरण चर, स्क्रिप्ट में गुप्त जानकारी डालने का लोकप्रिय तरीका हैं (12-factor ऐप्लिकेशन, CI/CD कार्य-श्रृंखलाएँ)। हालांकि, ये हर चाइल्ड प्रक्रिया तक पहुँच जाते हैं और प्रक्रिया के पूरे जीवनकाल में /proc/<pid>/environ में दिखाई देते हैं।

सुरक्षात्मक तरीके:

गुप्त जानकारी को तुरंत किसी स्थानीय चर में लें और पर्यावरण चर को हटाएँ, ताकि चाइल्ड प्रक्रियाएँ इसे विरासत में न ले सकें।
पूरे विरासत में मिले पर्यावरण के बजाय env -i या इनलाइन असाइनमेंट का उपयोग करके गुप्त जानकारी केवल विशिष्ट आदेशों को दें।
गुप्त चर को कभी export न करें — जहाँ संभव हो, केवल असाइनमेंट का उपयोग करें (बिना export के)।

#!/usr/bin/env bash
set -euo pipefail

# Simulate a secret arriving via environment (e.g., from CI system)
export DB_PASSWORD='hunter2'   # set by CI — we did not choose this

# Capture locally, then strip from environment immediately
db_password="$DB_PASSWORD"
unset DB_PASSWORD

# Verify the env var is gone before spawning any child process
if printenv DB_PASSWORD 2>/dev/null; then
  echo 'ERROR: DB_PASSWORD still in environment!' >&2
  exit 1
fi

echo 'Secret captured and env var scrubbed.'
echo "Password length: ${#db_password}"
unset db_password

set -x के ट्रेस में गुप्त जानकारी दिखने से रोकना

डिबगिंग के लिए set -x (xtrace) अत्यंत उपयोगी है, लेकिन यह अपने द्वारा विस्तारित किए गए हर चर का मान stderr पर छाप देता है — इसमें गुप्त जानकारी भी शामिल है। ये ट्रेस अक्सर CI अभिलेखों या syslog में पहुँच जाते हैं।

ट्रेसिंग को उपयोगी रखते हुए गुप्त जानकारी की सुरक्षा के तरीके:

{ set +x; } 2>/dev/null की सहायता से संवेदनशील कार्यों के आसपास ट्रेसिंग को अस्थायी रूप से बंद करें।
इसके बाद set -x से इसे फिर चालू करें।
xtrace आउटपुट को एक अलग फ़ाइल डिस्क्रिप्टर पर भेजें, जो सार्वजनिक अभिलेख-प्रवाह के बजाय किसी सुरक्षित अभिलेख फ़ाइल में जाए।

#!/usr/bin/env bash
set -euo pipefail
set -x   # tracing ON — safe for non-sensitive sections

echo 'Building application...'
SRC_DIR='/tmp/build'
mkdir -p "$SRC_DIR"

# Disable xtrace around secret handling (suppress the set +x line itself)
{ set +x; } 2>/dev/null

read -rsp 'Token (hidden from trace): ' SECRET_TOKEN <&2
printf '\n' >&2
token_len=${#SECRET_TOKEN}
unset SECRET_TOKEN

set -x  # tracing back ON

echo "Token captured (length=$token_len). Continuing build..."
ls "$SRC_DIR"

अभिलेख फ़ाइलों से गुप्त जानकारी हटाना

सावधानी बरतने पर भी कभी-कभी गुप्त जानकारी अभिलेख आउटपुट में पहुँच जाती है — खासकर विस्तृत या पुराने ढंग की स्क्रिप्ट में। ज्ञात प्रारूपों को छिपाने वाला अभिलेख-लेखन आवरण फ़ंक्शन एक अतिरिक्त सुरक्षा-जाल देता है।

इस तरीके में सभी अभिलेख आउटपुट पर नियमित-अभिव्यक्ति-आधारित प्रतिस्थापन किया जाता है। यह अंतिम उपाय की परत है, पहले बताए गए अन्य स्वच्छता-अभ्यासों का विकल्प नहीं।

#!/usr/bin/env bash
set -euo pipefail

# A logging function that scrubs common secret patterns before writing
log() {
  local line
  # Replace anything that looks like key=VALUE or password=VALUE
  line=$(printf '%s\n' "$*" \
    | sed -E 's/(password|token|secret|key)=[^[:space:]]*/\1=***REDACTED***/gi')
  printf '[%s] %s\n' "$(date -u '+%T')" "$line"
}

# Usage:
log 'Connecting to database with password=hunter2'
log 'Loaded API token=sk-abc123xyz secret'
log 'Build step completed successfully'   # unchanged

env -i के साथ पृथक पर्यावरण

env -i किसी आदेश को पूरी तरह खाली पर्यावरण के साथ शुरू करता है और विरासत में मिले सभी चरों — जिनमें गलती से शामिल गुप्त जानकारी भी है — को चाइल्ड प्रक्रिया तक पहुँचने से रोकता है। इसके बाद आप केवल आवश्यक चीज़ें स्पष्ट रूप से देते हैं।

यह अविश्वसनीय स्क्रिप्ट, निर्माण उपकरणों या ऐसे तृतीय-पक्ष उपयोगिताओं को चलाते समय विशेष रूप से उपयोगी है, जो पर्यावरण संबंधी जानकारी बाहर भेज सकती हैं।

#!/usr/bin/env bash
set -euo pipefail

# Polluted parent environment (simulating a CI runner)
export AWS_SECRET_ACCESS_KEY='AKIAIOSFODNN7EXAMPLE'
export GITHUB_TOKEN='ghp_faketoken123'
export HOME="$HOME"
export PATH="$PATH"

echo '--- Child sees full environment:'
env | grep -E 'AWS|GITHUB' | head -5

echo '--- Sanitised child (env -i) sees nothing secret:'
env -i HOME="$HOME" PATH="$PATH" TERM="${TERM:-dumb}" \
  bash -c 'env | grep -E "AWS|GITHUB" || echo "No secrets visible"'

unset AWS_SECRET_ACCESS_KEY GITHUB_TOKEN

tmpfs पर अस्थायी गुप्त जानकारी वाली फ़ाइलें

tmpfs RAM-आधारित फ़ाइल सिस्टम है। वहाँ लिखी गई फ़ाइलें कभी डिस्क पर भेजी नहीं जातीं, जिससे स्वैप, डिस्क कैश या स्नैपशॉट में गुप्त जानकारी के बचे रहने का जोखिम समाप्त हो जाता है।

Linux पर /dev/shm और /run/user/<uid> आम तौर पर tmpfs माउंट होते हैं।
स्क्रिप्ट समाप्त होने पर फ़ाइलें हटाने के लिए tmpfs के उपयोग के साथ हमेशा trap EXIT भी लगाएँ।
कंटेनरों (Docker, Kubernetes) में गुप्त जानकारी को सीधे /run/secrets में tmpfs वॉल्यूम के रूप में माउंट किया जा सकता है।

#!/usr/bin/env bash
set -euo pipefail

# Prefer /run/user/$UID (user-owned tmpfs) or /dev/shm (world-readable dir!)
if [[ -d "/run/user/$UID" ]]; then
  TMPFS_DIR="/run/user/$UID"
elif [[ -d '/dev/shm' ]]; then
  TMPFS_DIR='/dev/shm'
else
  # Fallback: warn that disk will be used
  echo 'WARNING: No tmpfs available; using /tmp (disk-backed)' >&2
  TMPFS_DIR='/tmp'
fi

SECRET_FILE=$(mktemp "${TMPFS_DIR}/secret.XXXXXX")
chmod 0600 "$SECRET_FILE"
trap 'shred -u "$SECRET_FILE" 2>/dev/null || rm -f "$SECRET_FILE"' EXIT

printf '%s' 'my-runtime-token' > "$SECRET_FILE"
echo "Secret stored in: $SECRET_FILE"
df -T "$SECRET_FILE" | awk 'NR==2 {print "Filesystem type:", $2}'

# Use the secret...
token=$(< "$SECRET_FILE")
echo "Token length: ${#token}"
unset token
# trap fires on exit: file shredded

सब कुछ एक साथ: सुदृढ़ परिनियोजन स्क्रिप्ट

निम्नलिखित स्क्रिप्ट इस पाठ में बताई गई सभी तकनीकों को एक वास्तविक परिनियोजन सहायक में जोड़ती है। ध्यान दें कि सुरक्षा की प्रत्येक परत दूसरी परतों को कैसे मज़बूत करती है:

stdin से पठन और -s — टर्मिनल पर कोई प्रतिध्वनि नहीं
tmpfs पर गुप्त जानकारी वाली फ़ाइल और trap से सफ़ाई
पर्यावरण की सफ़ाई — किसी भी उपप्रक्रिया से पहले गुप्त जानकारी वाला चर हटाना
xtrace सुरक्षा — संवेदनशील कोड के आसपास ट्रेस रोकना
अभिलेख में गुप्त जानकारी छिपाना — अभिलेख में लिखने से पहले सुरक्षा-जाल वाली नियमित अभिव्यक्ति

#!/usr/bin/env bash
set -euo pipefail

### 1. Redacting logger
log() {
  local msg
  msg=$(printf '%s' "$*" \
    | sed -E 's/(password|token|secret|key)=[^[:space:]]*/\1=***/gi')
  printf '[%s] %s\n' "$(date -u +%T)" "$msg"
}

### 2. tmpfs secret store
TMPFS_DIR="${XDG_RUNTIME_DIR:-/tmp}"
SECRET_FILE=$(mktemp "${TMPFS_DIR}/deploy_token.XXXXXX")
chmod 0600 "$SECRET_FILE"
trap 'rm -f "$SECRET_FILE"; log "Secret file cleaned up."' EXIT

### 3. Read secret without trace
{ set +x; } 2>/dev/null
read -rsp 'Deploy token: ' _tok <&2; printf '\n' >&2
printf '%s' "$_tok" > "$SECRET_FILE"
unset _tok
set -x

### 4. Scrub inherited env vars before subprocess
unset DEPLOY_TOKEN 2>/dev/null || true

log 'Starting deployment...'
# Simulate deploy using secret from file (token never in argv)
# curl -H "Authorization: Bearer $(< $SECRET_FILE)" https://api.example.com/deploy
log 'Deployment complete. token=hidden_by_redactor'

echo 'Done.'

ज्ञान जाँच: प्रक्रिया सूची के माध्यम से गुप्त जानकारी का खुलासा

जाँचें कि आप समझते हैं या नहीं कि प्रक्रिया सूचियों के माध्यम से गुप्त जानकारी कैसे बाहर निकलती है और इसे कैसे रोका जाए।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन: गुप्त जानकारी का सुरक्षित प्रबंधन

आपने गुप्त जानकारी का सुरक्षित प्रबंधन और पर्यावरण की स्वच्छता पूरा कर लिया है। अब तक शामिल सभी विषयों का संक्षिप्त संदर्भ यहाँ है:

प्रक्रिया सूचियाँ: गुप्त जानकारी को कभी भी आदेश-पंक्ति तर्क के रूप में न दें — वे ps aux और /proc/<pid>/cmdline में दिखाई देते हैं। इसके बजाय stdin पाइपिंग या --netrc-file का उपयोग करें।
stdin से पठन: टर्मिनल की प्रतिध्वनि या शेल इतिहास में खुलासे के बिना गुप्त जानकारी लेने के लिए read -rs का उपयोग करें।
फ़ाइल अनुमतियाँ: गुप्त जानकारी वाली फ़ाइलों पर chmod 0600 (या 0400) होना चाहिए। परमाणु रूप से बनाने के लिए install -m 0600 का उपयोग करें।
netrc फ़ाइलें: प्रमाण-पत्रों का प्रबंधन --netrc-file द्वारा निर्दिष्ट अस्थायी फ़ाइल को सौंपें; trap EXIT से सफ़ाई करें।
पर्यावरण की स्वच्छता: गुप्त पर्यावरण चरों को स्थानीय रूप से लेने के तुरंत बाद unset करें; उन्हें अनावश्यक रूप से कभी export न करें; चाइल्ड प्रक्रियाओं को अलग रखने के लिए env -i का उपयोग करें।
xtrace सुरक्षा: मानों को डिबग ट्रेस में बाहर निकलने से रोकने के लिए संवेदनशील कोड को { set +x; } 2>/dev/null ... set -x में रखें।
अभिलेख में गुप्त जानकारी छिपाना: अंतिम उपाय के सुरक्षा-जाल के रूप में sed-आधारित अभिलेख-लेखक का उपयोग करें।
tmpfs: चलन-समय की गुप्त जानकारी /run/user/$UID या /dev/shm में रखें, ताकि वह कभी डिस्क तक न पहुँचे; बाहर निकलते समय उसे सुरक्षित रूप से नष्ट करें।

गहराई में सुरक्षा ही मुख्य दृष्टिकोण है: कोई एक उपाय पर्याप्त नहीं होता, लेकिन सभी उपायों को परतों में लागू करने से गुप्त जानकारी का रिसाव अत्यंत कठिन हो जाता है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ DevOps बूटकैंप सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 142
पाठ: 568

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “गोपनीय जानकारी का सुरक्षित प्रबंधन और परिवेश की स्वच्छता” पाठ निःशुल्क है?

हाँ — DevOps बूटकैंप अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “गोपनीय जानकारी का सुरक्षित प्रबंधन और परिवेश की स्वच्छता” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। DevOps बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“गोपनीय जानकारी का सुरक्षित प्रबंधन और परिवेश की स्वच्छता” में मैं क्या सीखूँगा?

stdin, फ़ाइलों और साफ़ किए गए परिवेश का उपयोग करके क्रेडेंशियल को प्रोसेस सूची और लॉग से बाहर रखें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ DevOps बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या DevOps बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर DevOps बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“गोपनीय जानकारी का सुरक्षित प्रबंधन और परिवेश की स्वच्छता” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस DevOps बूटकैंप पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर DevOps बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

कमांड और तर्क इंजेक्शन रोकना
गोपनीय जानकारी का सुरक्षित प्रबंधन और परिवेश की स्वच्छता
न्यूनतम-अधिकार निष्पादन और sudo अनुशासन
ShellCheck से स्थैतिक विश्लेषण और ऑडिट

← DevOps बूटकैंप पर वापस जाएँ