Bazel ट्यूटोरियल: C++ प्रोजेक्ट बनाएं

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है किसी समस्या की शिकायत करें सोर्स देखें रात · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

परिचय

क्या Babel के लिए नए हैं? आप सही जगह पर हैं. Bazel का इस्तेमाल करने के बारे में आसानी से जानने के लिए, 'पहला बिल्ड' ट्यूटोरियल देखें. इस ट्यूटोरियल में, मुख्य शब्दों की परिभाषा दी गई है, क्योंकि इनका इस्तेमाल Bazel के संदर्भ में किया जाता है. साथ ही, इसमें आपको Bazel वर्कफ़्लो की बुनियादी जानकारी दी गई है. आपको अपनी ज़रूरत के हिसाब से टूल चुनने के बाद, तीन चरण पूरे करने होंगे बढ़ती जटिलता के प्रोजेक्ट हैं और जानें कि वे कैसे और क्यों ज़्यादा जटिल होते हैं.

Bazel एक बिल्ड सिस्टम है, जो कई भाषाओं में बिल्ड करने की सुविधा देता है. इस ट्यूटोरियल में, उदाहरण के तौर पर C++ प्रोजेक्ट का इस्तेमाल किया गया है. साथ ही, इसमें सामान्य दिशा-निर्देश और फ़्लो दिए गए हैं, जो ज़्यादातर भाषाओं पर लागू होते हैं.

पूरा होने का अनुमानित समय: 30 मिनट.

ज़रूरी शर्तें

अगर आपने अभी तक Basel का इस्तेमाल किया जा रहा है, तो उन्हें इंस्टॉल करने से शुरुआत करें पहले से मौजूद है. यह ट्यूटोरियल सोर्स कंट्रोल के लिए Git का इस्तेमाल करता है, इसलिए सबसे अच्छे नतीजे मिलते हैं Git इंस्टॉल करें करते हैं.

इसके बाद, नीचे दिए गए निर्देशों का पालन करें:

git clone https://github.com/bazelbuild/examples

इस ट्यूटोरियल के लिए सैंपल प्रोजेक्ट, examples/cpp-tutorial डायरेक्ट्री में है.

इसकी स्ट्रक्चर्ड जानकारी नीचे देखें:

examples
└── cpp-tutorial
    ├──stage1
    │  ├── main
    │  │   ├── BUILD
    │  │   └── hello-world.cc
    │  └── WORKSPACE
    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── WORKSPACE
    └──stage3
       ├── main
       │   ├── BUILD
       │   ├── hello-world.cc
       │   ├── hello-greet.cc
       │   └── hello-greet.h
       ├── lib
       │   ├── BUILD
       │   ├── hello-time.cc
       │   └── hello-time.h
       └── WORKSPACE

फ़ाइलों के तीन सेट हैं. हर सेट इस ट्यूटोरियल के एक चरण को दिखाता है. पहले चरण में, आपको किसी एक पैकेज में मौजूद कोई टारगेट बनाना होगा. दूसरे चरण में, आपको एक ही पैकेज से बाइनरी और लाइब्रेरी, दोनों बनानी होंगी. तय सीमा में तीसरा और आखिरी चरण है, तो आपको कई पैकेज वाला एक प्रोजेक्ट बनाना होगा और उसे कई लक्ष्यों के साथ बनाएं.

सारांश: परिचय

Bazel (और Git) इंस्टॉल करके और इस ट्यूटोरियल के लिए रिपॉज़िटरी को क्लोन करके, आपने Bazel की मदद से अपने पहले बिल्ड की नींव रख दी है. कुछ शब्दों की परिभाषा देने और अपना वर्कस्पेस सेट अप करने के लिए, अगले सेक्शन पर जाएं.

शुरू करना

फ़ाइल फ़ोल्डर सेट अप करना

प्रोजेक्ट बनाने से पहले, आपको उसका वर्कस्पेस सेट अप करना होगा. वर्कस्पेस एक ऐसी डायरेक्ट्री होती है जिसमें आपके प्रोजेक्ट की सोर्स फ़ाइलें और Bazel के बिल्ड आउटपुट मौजूद होते हैं. यह इसमें ये अहम फ़ाइलें भी शामिल होती हैं:

  • WORKSPACE file , जो डायरेक्ट्री और उसके कॉन्टेंट की पहचान बेज़ल वर्कस्पेस के तौर पर करता है और प्रोजेक्ट की डायरेक्ट्री स्ट्रक्चर के मूल में मौजूद होती है.
  • एक या एक से ज़्यादा BUILD files , जो Bazel को प्रोजेक्ट के अलग-अलग हिस्सों को बनाने का तरीका बताते हैं. ऐप्लिकेशन फ़ाइल फ़ोल्डर में मौजूद डायरेक्ट्री, जिसमें BUILD फ़ाइल है package. (पैकेज के बारे में ज़्यादा जानकारी देखें.)

आने वाले समय में, किसी डायरेक्ट्री को Baze Workspace के तौर पर इस्तेमाल करने के लिए, उस डायरेक्ट्री में WORKSPACE नाम की खाली फ़ाइल है. इस ट्यूटोरियल के लिए, एक WORKSPACE फ़ाइल पहले से ही हर चरण में मौजूद है.

ध्यान दें: जब Bazel प्रोजेक्ट बनाता है, तो सभी इनपुट एक ही वर्कस्पेस में होने चाहिए. अलग-अलग फ़ाइल फ़ोल्डर में मौजूद फ़ाइलें, एक-दूसरे से अलग होती हैं. हालांकि, लिंक करने पर वे एक-दूसरे से जुड़ जाती हैं. फ़ाइल फ़ोल्डर के नियमों के बारे में ज़्यादा जानकारी इस गाइड में मिल सकती है.

BUILD फ़ाइल को समझना

BUILD फ़ाइल में, Bazel के लिए कई तरह के निर्देश होते हैं. हर BUILD फ़ाइल के लिए, निर्देशों के सेट के तौर पर कम से कम एक नियम होना ज़रूरी है. इससे Bazel को, अपनी पसंद के आउटपुट बनाने का तरीका पता चलता है. जैसे, एक्ज़ीक्यूटेबल बाइनरी या लाइब्रेरी. BUILD फ़ाइल में, किसी बिल्ड नियम के हर इंस्टेंस को टारगेट कहा जाता है. साथ ही, यह सोर्स फ़ाइलों और डिपेंडेंसी के किसी खास सेट पर ले जाता है. टारगेट, दूसरे टारगेट पर भी ले जा सकता है.

cpp-tutorial/stage1/main डायरेक्ट्री में मौजूद BUILD फ़ाइल पर एक नज़र डालें:

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
)

हमारे उदाहरण में, hello-world टारगेट, Bazel के पहले से मौजूद cc_binary rule को इंस्टैंशिएट करता है. यह नियम बेज़ेल को निर्देश देता है कि वह hello-world.cc सोर्स फ़ाइल, किसी पर भी निर्भर नहीं है.

खास जानकारी: शुरू करना

अब आपको कुछ मुख्य शब्दों के बारे में पता है. साथ ही, आपको पता है कि इस प्रोजेक्ट और आम तौर पर Bazel के संदर्भ में, इनका क्या मतलब है. अगले सेक्शन में, आपको प्रोजेक्ट का पहला चरण बनाना होगा और उसे टेस्ट करना होगा.

पहला चरण: एक टारगेट, एक पैकेज

यह प्रोजेक्ट का पहला हिस्सा बनाने का समय है. विज़ुअल रेफ़रंस के लिए, प्रोजेक्ट के पहले चरण के सेक्शन का स्ट्रक्चर यह है:

examples
└── cpp-tutorial
    └──stage1
       ├── main
       │   ├── BUILD
       │   └── hello-world.cc
       └── WORKSPACE

cpp-tutorial/stage1 डायरेक्ट्री पर जाने के लिए, यह कमांड चलाएं:

cd cpp-tutorial/stage1

इसके बाद, यह चलाएं:

bazel build //main:hello-world

टारगेट लेबल में, //main: वाला हिस्सा, BUILD फ़ाइल की जगह होता है फ़ाइल फ़ोल्डर के रूट के मुताबिक है और hello-world इसमें टारगेट नाम है BUILD फ़ाइल.

Bazel से कुछ ऐसा दिखता है:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.267s, Critical Path: 0.25s

आपने अपना पहला Bazel टारगेट बनाया है. Bazel, वर्कस्पेस के रूट में bazel-bin डायरेक्ट्री में, बिल्ड आउटपुट को सेव करता है.

अब अपनी हाल ही में बनी बाइनरी की जांच करें. इससे:

bazel-bin/main/hello-world

इससे, प्रिंट किया हुआ “Hello world” मैसेज दिखेगा.

यहां पहले चरण का डिपेंडेंसी ग्राफ़ दिया गया है:

हैलो-वर्ल्ड के लिए डिपेंडेंसी ग्राफ़, सिंगल सोर्स फ़ाइल के साथ एक टारगेट दिखाता है.

खास जानकारी: पहला चरण

अब आपने अपना पहला बिल्ड पूरा कर लिया है, आपको इसकी बुनियादी जानकारी है कि कैसे एक स्ट्रक्चर है. अगले चरण में, एक अन्य टेंप्लेट जोड़ा जाएगा और टारगेट.

दूसरा चरण: एक से ज़्यादा बिल्ड टारगेट

छोटे प्रोजेक्ट के लिए एक टारगेट काफ़ी होता है. हालांकि, बड़े प्रोजेक्ट को कई टारगेट और पैकेज में बांटा जा सकता है. इससे यह तेज़ स्पीड से काम करता है इंक्रीमेंटल बिल्ड – इसका मतलब है कि Baze, बदलावों को सिर्फ़ दोबारा बनाता है – और एक ही बार में किसी प्रोजेक्ट के कई हिस्से बनाकर बनाया जाता है. इसका यह चरण ट्यूटोरियल में टारगेट जोड़ा जाता है और अगले चरण में पैकेज जोड़ा जाता है.

यह वह डायरेक्ट्री है जिस पर दूसरे चरण के लिए काम किया जा रहा है:

    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── WORKSPACE

cpp-tutorial/stage2/main डायरेक्ट्री में मौजूद BUILD फ़ाइल को यहां देखें:

cc_library(
    name = "hello-greet",
    srcs = ["hello-greet.cc"],
    hdrs = ["hello-greet.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-greet",
    ],
)

इस BUILD फ़ाइल की मदद से, Bazel सबसे पहले hello-greet लाइब्रेरी बनाता है. इसके लिए, वह Bazel में पहले से मौजूद cc_library rule का इस्तेमाल करता है. इसके बाद, वह hello-world बाइनरी बनाता है. इसमें deps एट्रिब्यूट hello-world का टारगेट बेज़ल को बताता है कि hello-greet hello-world बाइनरी बनाने के लिए लाइब्रेरी ज़रूरी है.

प्रोजेक्ट का यह नया वर्शन बनाने से पहले, आपको डायरेक्ट्री बदलनी होंगी. इसके लिए, cpp-tutorial/stage2 डायरेक्ट्री पर स्विच करने के लिए, यह तरीका अपनाएं:

cd ../stage2

अब इस जाने-पहचाने निर्देश का इस्तेमाल करके नई बाइनरी बनाई जा सकती है:

bazel build //main:hello-world

एक बार फिर, बेज़ल कुछ इस तरह पेश करते हैं:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.399s, Critical Path: 0.30s

अब आपके पास हाल ही में बनी बाइनरी की जांच करने का विकल्प है. इससे आपको एक और “Hello world” मिलता है:

bazel-bin/main/hello-world

अगर अब hello-greet.cc में बदलाव किया जाता है और प्रोजेक्ट को फिर से बनाया जाता है, तो Baज़र, प्रोजेक्ट को फिर से कंपाइल करता है उस फ़ाइल को कॉपी कर सकते हैं.

डिपेंडेंसी ग्राफ़ को देखने पर, यह देखा जा सकता है कि नमस्ते दुनिया ये पहले की तरह ही इनपुट हैं, लेकिन बिल्ड का स्ट्रक्चर अलग है:

`हैलो-वर्ल्ड` के लिए डिपेंडेंसी ग्राफ़, फ़ाइल में बदलाव करने के बाद स्ट्रक्चर में हुए बदलाव दिखाता है.

खास जानकारी: दूसरा चरण

अब आपने दो टारगेट के साथ प्रोजेक्ट बना लिया है. hello-world टारगेट बनाता है और एक अन्य टारगेट (//main:hello-greet) पर निर्भर है, जो दो अतिरिक्त सोर्स फ़ाइलें बनाता है. अगले सेक्शन में, इसे और बेहतर बनाएं और एक अन्य पैकेज जोड़ें.

तीसरा चरण: एक से ज़्यादा पैकेज

इस अगले चरण में, प्रोजेक्ट को कई पैकेज के साथ बनाया जाता है. नीचे दिए गए लेखों की संरचना और सामग्री पर एक नज़र डालें cpp-tutorial/stage3 डायरेक्ट्री:

└──stage3
   ├── main
   │   ├── BUILD
   │   ├── hello-world.cc
   │   ├── hello-greet.cc
   │   └── hello-greet.h
   ├── lib
   │   ├── BUILD
   │   ├── hello-time.cc
   │   └── hello-time.h
   └── WORKSPACE

यहां दिख रहा है कि अब दो सब-डायरेक्ट्री हैं और हर एक में एक BUILD फ़ाइल है. इसलिए, बैज के लिए, अब फ़ाइल फ़ोल्डर में दो पैकेज शामिल हैं: lib और main.

lib/BUILD फ़ाइल पर एक नज़र डालें:

cc_library(
    name = "hello-time",
    srcs = ["hello-time.cc"],
    hdrs = ["hello-time.h"],
    visibility = ["//main:__pkg__"],
)

और main/BUILD फ़ाइल पर:

cc_library(
    name = "hello-greet",
    srcs = ["hello-greet.cc"],
    hdrs = ["hello-greet.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-greet",
        "//lib:hello-time",
    ],
)

मुख्य पैकेज में hello-world टारगेट, lib पैकेज में मौजूद hello-time टारगेट पर निर्भर करता है (इसलिए टारगेट लेबल //lib:hello-time). Bazel को deps एट्रिब्यूट की मदद से इसकी जानकारी मिलती है. आपको यह जानकारी, डिपेंडेंसी ग्राफ़ में दिखेगी:

`हैलो-वर्ल्ड` के लिए डिपेंडेंसी ग्राफ़ दिखाता है कि मुख्य पैकेज में टारगेट, `lib` पैकेज के टारगेट पर कैसे निर्भर करता है.

बिल्ड को पूरा करने के लिए, आपको lib/BUILD में मौजूद //lib:hello-time टारगेट को main/BUILD में मौजूद टारगेट के लिए साफ़ तौर पर दिखने वाला बनाना होगा. इसके लिए, आपको विज़िबिलिटी एट्रिब्यूट का इस्तेमाल करना होगा. ऐसा इसलिए है क्योंकि डिफ़ॉल्ट रूप से लक्ष्य केवल उन्हीं अन्य लक्ष्यों को दिखाई देते हैं BUILD फ़ाइल. लाइब्रेरी जैसी समस्याओं से बचने के लिए, Bagel टारगेट विज़िबिलिटी का इस्तेमाल करता है इसमें, लागू करने की जानकारी शामिल है जो सार्वजनिक एपीआई में लीक हो रही है.

अब प्रोजेक्ट का यह फ़ाइनल वर्शन बनाएं. cpp-tutorial/stage3 डायरेक्ट्री पर स्विच करने के लिए, यह कमांड चलाएं:

cd  ../stage3

एक बार फिर से, नीचे दिया गया निर्देश चलाएं:

bazel build //main:hello-world

Bazel से कुछ ऐसा दिखता है:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 0.167s, Critical Path: 0.00s

अब आखिरी Hello world मैसेज के लिए, इस ट्यूटोरियल के आखिरी बाइनरी को टेस्ट करें:

bazel-bin/main/hello-world

खास जानकारी: तीसरा चरण

अब आपने प्रोजेक्ट को तीन टारगेट वाले दो पैकेज के तौर पर बनाया है और उनके बीच की डिपेंडेंसी को समझ लिया है. इससे, आपको आगे बढ़ने और Bazel की मदद से आने वाले समय में प्रोजेक्ट बनाने में मदद मिलेगी. अगले सेक्शन में, Bazel के साथ अपनी यात्रा जारी रखने का तरीका जानें.

अगले चरण

अब आपने Basel का इस्तेमाल करके, अपना पहला बेसिक बिल्ड पूरा कर लिया है. हालांकि, यह सिर्फ़ शुरू करें. Basel के साथ सीखने के लिए, यहां कुछ और संसाधन दिए गए हैं:

बिल्डिंग बनाने के लिए शुभकामनाएं!