ਬੈਂਚਮਾਰਕ ਲੋਕਲ LLM ਮਾਡਲ

ਪਰਿਯੋਜਨਾ ਦਾ GitHub ਰਿਪੋ

ਪਿਛੋਕੜ ਕਹਾਣੀ

ਮੈਂ LLM Speed Benchmark (LLMSB) ਉਸ ਸਮੇਂ ਬਣਾਇਆ ਜਦੋਂ ਮੈਂ Anarchy (YC W23) ਵਿੱਚ ਅੱਧੇ-ਟਾਈਮ ਇੰਜੀਨੀਅਰਿੰਗ ਇੰਟਰਨ ਵਜੋਂ ਕੰਮ ਕਰ ਰਿਹਾ ਸੀ। LLMSB ਇੱਕ ਬੈਂਚਮਾਰਕਿੰਗ ਟੂਲ ਹੈ ਜੋ ਇੱਕ LLM ਮਾਡਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ LLM ਮਾਡਲ ਨੂੰ ਲੋਡ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਲਈ HuggingFace ਦੀ transformers ਲਾਇਬ੍ਰੇਰੀ ਵਰਤਦਾ ਹੈ ਅਤੇ ਇਹ ਮਾਪਦਾ ਹੈ:

  • ਕੁੱਲ ਰਨਟਾਈਮ
  • ਪ੍ਰਤੀ ਸਕਿੰਟ ਟੋਕਨ
  • ਆਮ ਹਾਰਡਵੇਅਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ
  • CPU ਵਰਤੋਂ (ਮੌਜੂਦਾ ਫ੍ਰਿਕਵੈਂਸੀ ਅਤੇ ਸਮੇਂ ਦੇ ਨਾਲ ਕੋਰਾਂ ਦੀ ਵਰਤੋਂ %)
  • RAM ਵਰਤੋਂ (RAM ਅਤੇ swap ਸਮੇਂ ਦੇ ਨਾਲ)
  • GPU ਵਰਤੋਂ (ਲੋਡ, ਮੈਮੋਰੀ ਵਰਤੋਂ, ਅਤੇ ਤਾਪਮਾਨ ਸਮੇਂ ਦੇ ਨਾਲ)

ਇੱਥੇ codellama-13b-oasst-sft-v10 ਮਾਡਲ ਲਈ ਇੱਕ ਬੈਂਚਮਾਰਕ ਰਨ ਦੀ ਉਦਾਹਰਨ ਹੈ, ਜੋ H100 ‘ਤੇ ਚੱਲ ਰਿਹਾ ਹੈ। ਮੇਰੇ ਕੋਲ ਨਿੱਜੀ ਤੌਰ ‘ਤੇ ਇੱਕ Nvidia RTX 2070 Ti ਹੈ, ਜਿਸ ਵਿੱਚ 8 GB VRAM ਹੈ। ਦੁੱਖ ਦੀ ਗੱਲ ਹੈ ਕਿ ਜ਼ਿਆਦਾਤਰ ਆਧੁਨਿਕ LLM ਮਾਡਲਾਂ ਲਈ, 8 GB VRAM ਕਿਸੇ ਮਾਡਲ ਨਾਲ ਇੰਟਰਫੇਸ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ। ਇਸ ਕਰਕੇ, ਮੈਂ RunPod ਦਾ ਇਸਤੇਮਾਲ GPU(s) ਨੂੰ “ਕਿਰਾਏ ‘ਤੇ” ਲੈਣ ਲਈ ਕੀਤਾ ਅਤੇ ਕੁਝ ਮਾਡਲਾਂ ‘ਤੇ ਆਪਣੇ ਬੈਂਚਮਾਰਕ ਚਲਾਏ।

ਇਹ LLMSB ਦੀ ਪਿਛੋਕੜ/ਮੂਲ ਕਹਾਣੀ ਸੀ। ਕਿਉਂਕਿ ਪ੍ਰੋਜੈਕਟ ਓਪਨ-ਸੋਰਸ ਹੈ, ਤੁਸੀਂ ਕੋਡ ਇੱਥੇ ਦੇਖ ਸਕਦੇ ਹੋ। ਹੇਠਾਂ, ਮੈਂ ਰਿਪੋ ਦਾ README ਸ਼ਾਮਲ ਕੀਤਾ ਹੈ ਜੇ ਤੁਸੀਂ ਇਸਨੂੰ ਦੇਖਣਾ ਚਾਹੋ।

ਬਾਰੇ

🚧 LLM Speed Benchmark (LLMSB) ਇਸ ਸਮੇਂ ਬੀਟਾ (v0) ਵਿੱਚ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਇਸਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਨਾ ਵਰਤੋ, ਜਾਂ ਇਸਨੂੰ ਆਪਣੇ ਜੋਖ਼ਮ ‘ਤੇ ਵਰਤੋ। ਅਸੀਂ ਅਜੇ ਵੀ ਕੁਝ ਖਾਮੀਆਂ ਦੂਰ ਕਰ ਰਹੇ ਹਾਂ ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਰਹੇ ਹਾਂ। ਜੇ ਤੁਹਾਨੂੰ ਕੋਈ ਬੱਗ ਮਿਲਦੇ ਹਨ ਜਾਂ ਤੁਹਾਡੇ ਕੋਲ ਸੁਝਾਵ ਹਨ, ਕਿਰਪਾ ਕਰਕੇ ਉਨ੍ਹਾਂ ਨੂੰ ISSUES ਹੇਠਾਂ ਰਿਪੋਰਟ ਕਰੋ। ਤੁਹਾਡਾ ਫੀਡਬੈਕ ਬਹੁਤ ਕੀਮਤੀ ਹੈ!

LLM Speed Benchmark (LLMSB) ਇੱਕ ਬੈਂਚਮਾਰਕਿੰਗ ਟੂਲ ਹੈ ਜੋ ਵੱਖ-ਵੱਖ ਹਾਰਡਵੇਅਰ ਪਲੇਟਫਾਰਮਾਂ ‘ਤੇ LLM ਮਾਡਲਾਂ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਅੰਤਿਮ ਟੀਚਾ LLM ਮਾਡਲਾਂ ਦੀ ਵੱਖ-ਵੱਖ ਸਿਸਟਮਾਂ ‘ਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਬਾਰੇ ਇੱਕ ਵਿਸਤ੍ਰਿਤ ਡਾਟਾਸੈੱਟ ਤਿਆਰ ਕਰਨਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਸਹੀ LLM ਮਾਡਲ(ਜ਼) ਦੀ ਚੋਣ ਹੋਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਰਨ ਵਿੱਚ ਮਦਦ ਮਿਲੇ।

ਸੀਮਾਵਾਂ

LLMSB v0 ‘ਤੇ ਹੈ, ਇਸ ਲਈ ਇਸ ਵਿੱਚ ਸੀਮਾਵਾਂ ਹਨ:

  • ਸਿਰਫ਼ debian-ਅਧਾਰਿਤ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ‘ਤੇ ਚਲਾਉਣ ਲਈ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਰਥਾਤ ਇਹ Windows ‘ਤੇ ਚਲਾਉਣ ਲਈ ਡਿਜ਼ਾਇਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ। ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ LLMSB ਅੰਦਰੂਨੀ ਤੌਰ ‘ਤੇ ਮੈਟ੍ਰਿਕਸ ਇਕੱਠੇ ਕਰਨ ਲਈ neofetch ਅਤੇ nvidia-smi ਵਰਤਦਾ ਹੈ ਅਤੇ filepath ਲਾਜ਼ਿਕ unix ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ‘ਤੇ ਅਧਾਰਿਤ ਹੈ।
  • ਮੈਟ੍ਰਿਕਸ ਦੇ ਰਿਕਾਰਡ ਹੋਣ ਦੇ ਤਰੀਕੇ ਕਰਕੇ, ਮੈਟ੍ਰਿਕਸ ਕਲੇਕਟਰ ਨੂੰ ਇੱਕ ਕਲੇਕਸ਼ਨ ਕਰਨ ਲਈ 1 ਸਕਿੰਟ ਤੱਕ ਲੱਗ ਸਕਦਾ ਹੈ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ, ਸਭ ਤੋਂ ਤੇਜ਼ ਹਾਲਤ ਵਿੱਚ, ਅਸੀਂ ਹਰ 1 ਸਕਿੰਟ ਬਾਅਦ ਹਾਰਡਵੇਅਰ ਮੈਟ੍ਰਿਕਸ ਇਕੱਠੇ ਕਰ ਸਕਦੇ ਹਾਂ।
  • LLMSB ਸਿਰਫ਼ ਮਾਡਲਾਂ ਨੂੰ ਲੋਡ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਲਈ HuggingFace ਵਰਤਦਾ ਹੈ। ਇਹ ਹੁਣ ਲਈ ਠੀਕ ਹੈ, ਪਰ ਟੀਚਾ ਇਹ ਹੈ ਕਿ LLMSB ਕਈ ਫਰੇਮਵਰਕਾਂ ਨੂੰ ਸਹਿਯੋਗ ਦੇਵੇ, ਸਿਰਫ਼ HuggingFace ਨੂੰ ਨਹੀਂ।
  • ਇਸ ਵੇਲੇ, ਸਾਰੇ ਮਾਡਲ run_llm() ਫੰਕਸ਼ਨ ਵਿੱਚ ਦਰਸਾਈ ਗਈ ਲਾਜ਼ਿਕ ਰਾਹੀਂ ਚਲਾਏ ਜਾਂਦੇ ਹਨ, ਜੋ src/hf.py ਵਿੱਚ ਮੌਜੂਦ ਹੈ, ਜਿੱਥੇ AutoTokenizer() ਅਤੇ AutoModelForCausalLM() ਫੰਕਸ਼ਨਾਂ ਦਾ ਇਸਤੇਮਾਲ ਮਾਡਲ ਨੂੰ ਲੋਡ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਲਈ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਇਹ ਸੀਮਿਤ ਕਰਦਾ ਹੈ ਕਿ ਅਸੀਂ ਖਾਸ ਮਾਡਲਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਰਚਿਤ/ਅਪਟੀਮਾਈਜ਼ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਹ ਜਾਣਦੇ ਹੋਏ, ਟੀਚਾ ਹਰ ਲੋਕਪ੍ਰਿਯ ਮਾਡਲ ਲਈ ਵੱਖ-ਵੱਖ ਕਲਾਸਾਂ ਬਣਾਉਣ ਅਤੇ ਇਸਦੀ ਬਜਾਇ HuggingFace ਦੀਆਂ ਮਾਡਲ-ਵਿਸ਼ੇਸ਼ ਕਲਾਸਾਂ, ਜਿਵੇਂ LlamaTokenizer ਅਤੇ LlamaForCausalLM, ਵਰਤਣ ਦਾ ਹੈ।
  • LLMSB ਸਿਰਫ਼ ਆਮ, ਉੱਚ-ਪੱਧਰੀ, ਮੈਟ੍ਰਿਕਸ ਇਕੱਠੇ ਕਰਦਾ ਹੈ। ਭਵਿੱਖ ਵਿੱਚ, ਅਸੀਂ ਨੀਵੇਂ-ਪੱਧਰੀ ਮੈਟ੍ਰਿਕਸ ਇਕੱਠੇ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਅਸੀਂ ਸੋਚਦੇ ਹਾਂ ਕਿ ਇਹ ਕੁਝ ਹੱਦ ਤੱਕ Pytorch ਦੇ porfiler wrapper ਦੀ ਵਰਤੋਂ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਨਮੂਨਾ ਨਤੀਜੇ

22 ਨਵੰਬਰ, 2023

LLMSB ਨੂੰ RunPod ਰਾਹੀਂ ਇੱਕ L40 ਅਤੇ H100 GPU ‘ਤੇ ਚਲਾਇਆ/ਟੈਸਟ ਕੀਤਾ ਗਿਆ ਸੀ। ਉਨ੍ਹਾਂ ਬੈਂਚਮਾਰਕਾਂ ਵਿੱਚ llama-2-7b-hf, codellama-13b-oasst-sft-v10, ਅਤੇ mpt-7b ਮਾਡਲਾਂ ਦੀ ਜਾਂਚ ਕੀਤੀ ਗਈ ਸੀ। ਨਤੀਜੇ ਇੱਥੇ ਦੇਖੋ। ਜੇ ਕੋਈ ਗਲਤੀਆਂ/ਮਸਲੇ ਨਜ਼ਰ ਆਉਣ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਉਨ੍ਹਾਂ ਨੂੰ ISSUES ਵਿੱਚ ਰਿਪੋਰਟ ਕਰੋ।

ਸੈੱਟਅੱਪ

  1. ਪਾਈਥਨ ਵਾਤਾਵਰਣ ਬਣਾਓ ਅਤੇ ਸਰਗਰਮ ਕਰੋ:

    python3 -m venv env
source env/bin/activate

  2. ਪੈਕੇਜ ਨਿਰਭਰਤਾਵਾਂ ਇੰਸਟਾਲ ਕਰੋ (APT ਦੀ ਵਰਤੋਂ ਨਾਲ):

    apt -y update
apt install -y vim
apt install -y neofetch

  3. ਪਾਈਥਨ ਨਿਰਭਰਤਾਵਾਂ ਇੰਸਟਾਲ ਕਰੋ:

    pip3 install transformers
pip3 install psutil
pip3 install gputil
pip3 install tabulate
pip3 install sentencepiece
pip3 install protobuf

  4. Pytorch ਇੰਸਟਾਲ ਕਰੋ

    # CUDA 12.1 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, linux ਲਈ pytorch ਦਾ stable build ਇੰਸਟਾਲ ਕਰੋ:
pip3 install torch torchvision torchaudio

  5. LLM-VM ਇੰਸਟਾਲ ਕਰੋ:

    pip install llm-vm

  6. (ਵਿਕਲਪਿਕ) ਜੇ ਤੁਸੀਂ LLAMA ਵਰਗੇ ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ HuggingFace ਐਕਸੇਸ ਟੋਕਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਆਪਣਾ ਐਕਸੇਸ ਟੋਕਨ ਇੱਥੇ ਸੈੱਟ ਕਰੋ, ਫਿਰ ਹੇਠਾਂ ਦਿੱਤਾ ਕਮਾਂਡ ਚਲਾ ਕੇ ਆਪਣਾ ਟੋਕਨ ਆਪਣੇ ਕਨਸੋਲ ਵਿੱਚ ਸੇਵ ਕਰੋ:

    huggingface-cli login

ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ

  1. ਸੈੱਟਅੱਪ ਭਾਗ ਵਿੱਚ ਦਰਜ ਕਦਮ ਪੂਰੇ ਕਰੋ।

  2. ਆਪਣਾ ਸੈੱਟ ਕਨਫਿਗਰ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ ਇੱਕ json ਫਾਈਲ ਬਣਾਉਣੀ ਪਵੇਗੀ (ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ):

    • ਨੋਟ: ਹਰ ਫਰੇਮਵਰਕ ਇੱਕੋ ਜਿਹੇ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸਹਿਯੋਗ ਨਹੀਂ ਦਿੰਦਾ
    {
  "model": "bigscience/bloom-560m",   # HuggingFace 'ਤੇ ਮਾਡਲ ਦਾ path/repo (https://huggingface.co/models)
  "prompt": "Hello World!",           # ਉਹ prompt ਜੋ ਤੁਸੀਂ LLM ਮਾਡਲ ਵਿੱਚ input ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ
  "device": "cuda:0",                 # ਉਹ ਡਿਵਾਈਸ ਜਿਸ 'ਤੇ ਤੁਸੀਂ LLM ਮਾਡਲ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ (GPU/CPU)
  "max_length": 50,                   # ਬਣਾਏ ਗਏ tokens ਦੀ ਅਧਿਕਤਮ ਲੰਬਾਈ
  "temperature": 0.9,                 # LLM ਮਾਡਲ ਲਈ temperature ਮੁੱਲ
  "top_k": 50,                        # LLM ਮਾਡਲ ਲਈ top-k ਮੁੱਲ
  "top_p": 0.9,                       # LLM ਮਾਡਲ ਲਈ top-p ਮੁੱਲ
  "num_return_sequences": 1,          # ਮਾਡਲ ਦੇ ਸਵਤੰਤਰ ਤੌਰ 'ਤੇ ਚਲਾਏ ਗਏ instances ਦੀ ਗਿਣਤੀ
  "time_delay": 0,                    # ਸਮੇਂ ਦੀ ਦੇਰੀ (ਸਕਿੰਟ) ਜੋ ਮੈਟ੍ਰਿਕਸ-ਕਲੇਕਟਰ ਹਰ ਇਟਰੈਸ਼ਨ ਪ੍ਰਤੀ ਉਡੀਕੇਗਾ
  "model_start_pause": 1,             # ਸਮਾਂ (ਸਕਿੰਟ) ਜੋ ਟੈਸਟ LLM ਮਾਡਲ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਉਡੀਕੇਗਾ
  "model_end_pause": 1                # ਸਮਾਂ (ਸਕਿੰਟ) ਜੋ ਟੈਸਟ LLM ਮਾਡਲ ਦੇ ਚੱਲਣ ਤੋਂ ਬਾਅਦ ਉਡੀਕੇਗਾ,
  "framework": "llm-vm"               # ਉਸ ਫਰੇਮਵਰਕ/ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਨਾਮ ਜੋ ਤੁਸੀਂ ਮਾਡਲ ਚਲਾਉਣ ਲਈ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ
}

  3. ਪਿਛਲੇ ਕਦਮ ਵਿੱਚ ਬਣਾਈ ਕਨਫਿਗ ਫਾਈਲ ਦੇ path ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਬੈਂਚਮਾਰਕ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਚਲਾਓ (ਇੱਕ ਵਿਕਲਪ ਚੁਣੋ):

    # ਇੱਕ ਬੈਂਚਮਾਰਕ ਚਲਾਓ
python3 run.py --config ./configs/llmvm_test.json

# ਇੱਕ ਤੋਂ ਵੱਧ ਬੈਂਚਮਾਰਕ ਚਲਾਓ (ਇਸ ਮਾਮਲੇ ਵਿੱਚ 3)
python3 run.py --config ./configs/llmvm_test.json --loops 3

  4. ਬੈਂਚਮਾਰਕ ਚੱਲਣ ਦੇ ਬਾਅਦ, ਅੰਤਿਮ ਨਤੀਜੇ ਉਸ ਫਾਈਲ ਵਿੱਚ ਦੇਖੋ ਜੋ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਣੀ ਚਾਹੀਦੀ ਹੈ:

    report_2023-11-25_05:55:04.207515_utc_1ffc4fa7-3aa9-4878-b874-1ff445e1ff8a.json

RunPod ਸੈੱਟਅੱਪ ਕਰਨਾ:

  1. RunPod ਸੈੱਟਅੱਪ ਕਰੋ, ਆਪਣਾ ssh cert/key ਸੈੱਟ ਕਰੋ, ਅਤੇ ਇੱਕ pod ਚਲਾਓ। ਤੁਸੀਂ ਆਪਣੇ pod(s) ਤੱਕ RunPod ਦੇ Console Page ‘ਤੇ ਪਹੁੰਚ ਸਕਦੇ ਹੋ।

  2. ssh ਕਨੈਕਸ਼ਨ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ “Connect” ਬਟਨ ‘ਤੇ ਕਲਿੱਕ ਕਰੋ। ਇਹ ਜਾਣਕਾਰੀ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸੇਗੀ:

    ssh root&12.345.678.90 -p 12345 -i ~/.ssh/id_example

    • ਇਹ ਕਮਾਂਡ ਇਸ ਤਰ੍ਹਾਂ ਫਾਰਮੈਟ ਕੀਤੀ ਜਾਵੇਗੀ:

      ssh <user>@<ip-address> -p <port> -i <local-path-to-ssh-cert>

  3. ਕਦਮ #2 ਵਿੱਚ ਦਿੱਤੀ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਹਾਨੂੰ pod ਵਿੱਚ ssh ਕਰਨ ਅਤੇ ਉਸ RunPod pod ਵਿੱਚ ਆਪਣੀ ਚੁਣੀ ਹੋਈ GPU ਵਰਤਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

  4. ਜੇ ਤੁਸੀਂ pod ਤੋਂ ਆਪਣੇ ਲੋਕਲ ਮਸ਼ੀਨ ‘ਤੇ ਕੋਈ ਫਾਈਲ ਕਾਪੀ ਕਰਨੀ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਫਾਰਮੈਟ ਵਿੱਚ ਕਮਾਂਡ ਚਲਾਉਗੇ (ਇਹ ਕਦਮ #2 ਵਿੱਚ ਦਿਖਾਏ ਗਏ variables ਨੂੰ ਦਰਸਾ ਰਿਹਾ ਹੈ):

    scp -P <port> -i <local-path-to-ssh-cert> <user>@<ip-address>:<path-to-file-in-pod> <path-to-local-directory>

    • ਇੱਥੇ ਅਜਿਹੀ ਕਮਾਂਡ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ:

      scp -P 12345 -i ~/.ssh/id_example <user>@<ip-address>:/root/test.txt /home/user1/Downloads/

  5. pod ਨਾਲ ਕੰਮ ਮੁਕੰਮਲ ਹੋਣ ਦੇ ਬਾਅਦ, ਇਸਨੂੰ shut down ਜਾਂ pause ਕਰੋ। ਪਰ ਚੇਤਾਵਨੀ, ਜੇ ਤੁਸੀਂ ਇਸਨੂੰ pause ਕਰਦੇ ਹੋ ਤਾਂ ਵੀ ਤੁਹਾਡੇ ਤੋਂ ਚਾਰਜ ਲੱਗਦਾ ਰਹੇਗਾ, ਸਿਰਫ਼ ਕਾਫ਼ੀ ਘੱਟ।

ਵਧੀਆ ਸਰੋਤ: