लगभग एक साल पहले, हमारी कंपनी मैग्नेटो 1 में विशाल मोनोलिथ को माइक्रोसर्विस में अलग करने की ओर अग्रसर हुई। आधार के रूप में, उन्होंने केवल सिम्फनी 4 को चुना, जो रिलीज में जारी किया गया था। इस समय के दौरान मैंने इस रूपरेखा पर कई परियोजनाएं विकसित कीं, लेकिन मैंने विशेष रूप से सिम्फनी के लिए बंडल, पुन: उपयोग किए गए घटकों को विकसित करना दिलचस्प पाया। बिल्ली के नीचे, साइफ़मोनी 4.1 के तहत एक माइक्रोसैस की स्थिति / स्वास्थ्य प्राप्त करने के लिए हेल्थचेक बंडल विकसित करने पर एक कदम-दर-चरण मार्गदर्शिका, जिसमें मैंने सबसे दिलचस्प और जटिल (मेरे लिए एक बार) क्षणों को छूने की कोशिश की।

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

एक बंडल कंकाल बनाएँ

सिम्फनी 3 में, बंडल कंकाल पैदा करने के लिए एक सुविधाजनक बंडल था, लेकिन सिम्फनी 4 में यह अब समर्थित नहीं है और इसलिए आपको कंकाल खुद बनाना होगा। मैं एक टीम लॉन्च करके प्रत्येक नए प्रोजेक्ट का विकास शुरू करता हूं

composer create-project symfony/skeleton health-check

कृपया ध्यान दें कि सिम्फनी 4 PHP 7.1+ का समर्थन करता है, इसलिए यदि आप नीचे दिए गए संस्करण पर इस कमांड को चलाते हैं, तो आपको सिम्फनी 3 के लिए प्रोजेक्ट कंकाल मिलेगा।

यह कमांड निम्नलिखित संरचना के साथ एक नया सिम्फनी 4.1 प्रोजेक्ट बनाता है:

सिद्धांत रूप में, यह आवश्यक नहीं है, क्योंकि बनाई गई फ़ाइलों के कारण हमें अंत में बहुत अधिक आवश्यकता नहीं है, लेकिन मेरे लिए यह उन सभी चीजों को साफ करने के लिए अधिक सुविधाजनक है जो मेरे हाथों से आवश्यक बनाने की तुलना में आवश्यक नहीं है।

composer.json

अगला कदम composer.json को हमारी जरूरतों को संपादित करना है। सबसे पहले, आपको प्रोजेक्ट type को symfony-bundle बदलने की आवश्यकता है symfony-bundle यह सिम्फनी फ्लेक्स को प्रोजेक्ट में एक बंडल जोड़ते समय यह निर्धारित करने में मदद करेगा कि यह वास्तव में एक सिम्फनी बंडल है, स्वचालित रूप से इसे कनेक्ट करें और नुस्खा स्थापित करें (लेकिन बाद में उस पर और अधिक)। अगला, name और description फ़ील्ड जोड़ना सुनिश्चित करें। name इसलिए भी महत्वपूर्ण है क्योंकि यह निर्धारित करता है कि vendor अंदर कौन सा फ़ोल्डर बंडल रखा जाएगा।

 "name": "niklesh/health-check", "description": "Health check bundle",

अगला महत्वपूर्ण कदम autoload अनुभाग को संपादित करना है, जो बंडल कक्षाओं को लोड करने के लिए जिम्मेदार है। काम के माहौल के लिए autoload , काम के माहौल के लिए autoload-dev ।

 "autoload": { "psr-4": { "niklesh\\HealthCheckBundle\\": "src" } }, "autoload-dev": { "psr-4": { "niklesh\\HealthCheckBundle\\Tests\\": "tests" } },

scripts अनुभाग को हटाया जा सकता है। इसमें संपत्तियों को इकट्ठा composer install और composer install और composer update कमांड को निष्पादित करने के बाद कैश को साफ़ करने के लिए स्क्रिप्ट होती है, हालांकि, हमारे बंडल में कोई भी संपत्ति या कैश नहीं होता है, इसलिए ये कमांड बेकार हैं।

अंतिम चरण require और require-dev वर्गों को संपादित करना require । परिणामस्वरूप, हमें निम्नलिखित मिलते हैं:

 "require": { "php": "^7.1.3", "ext-ctype": "*", "ext-iconv": "*", "symfony/flex": "^1.0", "symfony/framework-bundle": "^4.1", "sensio/framework-extra-bundle": "^5.2", "symfony/lts": "^4@dev", "symfony/yaml": "^4.1" }

मैं ध्यान देता हूं कि जब बंडल कार्यशील मसौदे से जुड़ा होता है, तो require से निर्भरता स्थापित require जाएगी।

हम composer update शुरू करते हैं - निर्भरताएं स्थापित की जाती हैं।

अनावश्यक सफाई

तो, प्राप्त फ़ाइलों से आप निम्न फ़ोल्डरों को सुरक्षित रूप से हटा सकते हैं:

बिन - सिम्फनी कमांड चलाने के लिए आवश्यक console फ़ाइल है
कॉन्फिगरेशन - राउटिंग, कनेक्टेड बंडलों के लिए कंफिगरेशन फाइल्स,
सेवाओं, आदि
सार्वजनिक - इसमें index.php - अनुप्रयोग का प्रवेश बिंदु होता है
var - लॉग और cache यहाँ संग्रहीत हैं

हम src/Kernel.php , .env , .env.dist भी हटाते हैं
हमें यह सब करने की आवश्यकता नहीं है क्योंकि हम एक आवेदन नहीं बल्कि एक बंडल विकसित कर रहे हैं।

एक बंडल संरचना बनाना

इसलिए, हमने आवश्यक निर्भरता को जोड़ा और हमारे बंडल से जरूरी सब कुछ साफ किया। यह बंडल और प्रोजेक्ट को सफलतापूर्वक प्रोजेक्ट से कनेक्ट करने के लिए आवश्यक फ़ाइलें और फ़ोल्डर्स बनाने का समय है।

सबसे पहले, src फोल्डर में, HealthCheckBundle.php फ़ाइल को निम्न सामग्री के साथ बनाएँ:

 <?php namespace niklesh\HealthCheckBundle; use Symfony\Component\HttpKernel\Bundle\Bundle; class HealthCheckBundle extends Bundle { }

ऐसी कक्षा हर बंडल में होनी चाहिए जो आप बनाते हैं। वह मुख्य परियोजना के config/bundles.php में config/bundles.php किया जाएगा। इसके अलावा, वह बंडल के "निर्माण" को प्रभावित कर सकता है।

अगले बंडल घटक की जरूरत है DependencyInjection खंड। 2 फ़ाइलों के साथ एक ही नाम का फ़ोल्डर बनाएँ:

src/DependencyInjection/Configuration.php

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection; use Symfony\Component\Config\Definition\Builder\TreeBuilder; use Symfony\Component\Config\Definition\ConfigurationInterface; class Configuration implements ConfigurationInterface { public function getConfigTreeBuilder() { $treeBuilder = new TreeBuilder(); $treeBuilder->root('health_check'); return $treeBuilder; } }

यह फ़ाइल यमल या xml फ़ाइलों से बंडल कॉन्फ़िगरेशन को पार्स करने और मान्य करने के लिए ज़िम्मेदार है। हम इसे बाद में संशोधित करेंगे।

src/DependencyInjection/HealthCheckExtension.php

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection; use Symfony\Component\Config\FileLocator; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\HttpKernel\DependencyInjection\Extension; use Symfony\Component\DependencyInjection\Loader; class HealthCheckExtension extends Extension { /** * {@inheritdoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $this->processConfiguration($configuration, $configs); $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yaml'); } }

यह फ़ाइल बंडल कॉन्फ़िगरेशन फ़ाइलों को लोड करने, "परिभाषा" सेवाओं को बनाने और पंजीकृत करने, एक कंटेनर में लोड करने के मापदंडों आदि के लिए जिम्मेदार है।

और इस स्तर पर अंतिम चरण src/Resources/services.yaml फ़ाइल को जोड़ना है, जिसमें हमारी बंडल सेवाओं का विवरण होगा। इसे अभी के लिए खाली छोड़ दें।

HealthInterface

हमारे बंडल का मुख्य कार्य उस परियोजना के बारे में डेटा वापस करना होगा जिसमें इसका उपयोग किया जाता है। लेकिन सूचना का संग्रह स्वयं सेवा का काम है, हमारा बंडल केवल उस जानकारी के प्रारूप को इंगित कर सकता है जिसे सेवा को प्रेषित करना चाहिए, और जिस विधि से यह जानकारी प्राप्त होगी। मेरे कार्यान्वयन में, सभी सेवाएं (और कई हो सकती हैं) जो जानकारी एकत्र करती हैं उन्हें HealthInterface इंटरफ़ेस को 2 तरीकों से लागू करना चाहिए: getName और getHealthInfo । बाद वाले को HealthDataInterface इंटरफ़ेस को लागू करने वाली ऑब्जेक्ट को वापस करना चाहिए।

सबसे पहले, src/Entity/HealthDataInterface.php डेटा इंटरफ़ेस बनाएँ:

 <?php namespace niklesh\HealthCheckBundle\Entity; interface HealthDataInterface { public const STATUS_OK = 1; public const STATUS_WARNING = 2; public const STATUS_DANGER = 3; public const STATUS_CRITICAL = 4; public function getStatus(): int; public function getAdditionalInfo(): array; }

डेटा में एक पूर्णांक स्थिति और अतिरिक्त जानकारी होनी चाहिए (जो, वैसे, खाली हो सकती है)।

चूँकि इस इंटरफ़ेस के लागू होने की सबसे अधिक संभावना है, अधिकांश वंशज, मैंने इसे src/Entity/CommonHealthData.php जोड़ने का निर्णय लिया:

 <?php namespace niklesh\HealthCheckBundle\Entity; class CommonHealthData implements HealthDataInterface { private $status; private $additionalInfo = []; public function __construct(int $status) { $this->status = $status; } public function setStatus(int $status) { $this->status = $status; } public function setAdditionalInfo(array $additionalInfo) { $this->additionalInfo = $additionalInfo; } public function getStatus(): int { return $this->status; } public function getAdditionalInfo(): array { return $this->additionalInfo; } }

अंत में, src/Service/HealthInterface.php डेटा संग्रह सेवाओं के लिए इंटरफ़ेस जोड़ें:

 <?php namespace niklesh\HealthCheckBundle\Service; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; interface HealthInterface { public function getName(): string; public function getHealthInfo(): HealthDataInterface; }

नियंत्रक

कंट्रोलर प्रोजेक्ट के बारे में सिर्फ एक रूट में डेटा देगा। लेकिन यह मार्ग इस बंडल का उपयोग करने वाली सभी परियोजनाओं के लिए समान होगा: /health

हालाँकि, हमारे कंट्रोलर का कार्य केवल डेटा देना नहीं है, बल्कि यह उन सेवाओं से बाहर निकलना भी है जो HealthInterface कार्यान्वित HealthInterface ; तदनुसार, नियंत्रक को इनमें से प्रत्येक सेवा के लिंक को स्टोर करना होगा। नियंत्रक के लिए सेवाओं को जोड़ने के लिए addHealthService विधि जिम्मेदार होगी

नियंत्रक जोड़ें src/Controller/HealthController.php :

 <?php namespace niklesh\HealthCheckBundle\Controller; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\Routing\Annotation\Route; class HealthController extends AbstractController { /** @var HealthInterface[] */ private $healthServices = []; public function addHealthService(HealthInterface $healthService) { $this->healthServices[] = $healthService; } /** * @Route("/health") * @return JsonResponse */ public function getHealth(): JsonResponse { return $this->json(array_map(function (HealthInterface $healthService) { $info = $healthService->getHealthInfo(); return [ 'name' => $healthService->getName(), 'info' => [ 'status' => $info->getStatus(), 'additional_info' => $info->getAdditionalInfo() ] ]; }, $this->healthServices)); } }

संकलन

सिम्फनी एक विशिष्ट इंटरफ़ेस को लागू करने वाली सेवाओं के साथ कुछ क्रियाएं कर सकती है। आप एक विशिष्ट विधि को कॉल कर सकते हैं, एक टैग जोड़ सकते हैं, लेकिन आप ऐसी सभी सेवाओं को किसी अन्य सेवा (जो नियंत्रक है) में ले और इंजेक्ट नहीं कर सकते। इस समस्या को 4 चरणों में हल किया गया है:

हम HealthInterface टैग को लागू करने HealthInterface अपनी प्रत्येक HealthInterface में HealthInterface ।

इंटरफ़ेस में TAG स्थिरांक जोड़ें:

 interface HealthInterface { public const TAG = 'health.service'; }

इसके बाद, आपको इस टैग को प्रत्येक सेवा में जोड़ना होगा। प्रोजेक्ट कॉन्फ़िगरेशन के मामले में, यह हो सकता है
_instanceof अनुभाग में config/services.yaml फ़ाइल में लागू करें। हमारे मामले में, यह
प्रविष्टि इस तरह दिखाई देगी:

 serivces: _instanceof: niklesh\HealthCheckBundle\Service\HealthInterface: tags: - !php/const niklesh\HealthCheckBundle\Service\HealthInterface::TAG

और, सिद्धांत रूप में, यदि आप उपयोगकर्ता को बंडल के कॉन्फ़िगरेशन को सौंपते हैं, तो यह काम करेगा, लेकिन मेरी राय में यह सही दृष्टिकोण नहीं है, बंडल को सही ढंग से जोड़ा जाना चाहिए और परियोजना में जोड़े जाने पर न्यूनतम उपयोगकर्ता हस्तक्षेप से कॉन्फ़िगर किया जाना चाहिए। किसी को याद हो सकता है कि बंडल के अंदर हमारी अपनी services.yaml हैं। लेकिन, यह हमारी मदद नहीं करेगा। यह सेटिंग केवल तभी काम करती है जब यह प्रोजेक्ट फ़ाइल में हो, बंडल नहीं।
मुझे नहीं पता कि यह एक बग या एक विशेषता है, लेकिन अब हमारे पास वही है जो हमारे पास है। इसलिए, हमें बंडल संकलन प्रक्रिया में घुसपैठ करनी होगी।

src/HealthCheckBundle.php और build विधि को फिर से परिभाषित करें:

 <?php namespace niklesh\HealthCheckBundle; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\HttpKernel\Bundle\Bundle; class HealthCheckBundle extends Bundle { public function build(ContainerBuilder $container) { parent::build($container); $container->registerForAutoconfiguration(HealthInterface::class)->addTag(HealthInterface::TAG); } }

अब HealthInterface को लागू करने वाले हर वर्ग को टैग किया जाएगा।

नियंत्रक को सेवा के रूप में पंजीकृत करना

अगले चरण में, हमें बंडल को संकलित करने के चरण में एक सेवा के रूप में नियंत्रक से संपर्क करना होगा। परियोजना के साथ काम करने के मामले में, सभी वर्गों को डिफ़ॉल्ट रूप से सेवाओं के रूप में पंजीकृत किया जाता है, लेकिन बंडल के साथ काम करने के मामले में हमें स्पष्ट रूप से यह निर्धारित करना होगा कि कौन सी कक्षाएं सेवाएं होंगी, उनके लिए तर्क रखें, इंगित करें कि क्या वे सार्वजनिक होंगे।

src/Resources/config/services.yaml फ़ाइल खोलें और निम्नलिखित सामग्री जोड़ें

 services: niklesh\HealthCheckBundle\Controller\HealthController: autoconfigure: true

हमने नियंत्रक को सेवा के रूप में स्पष्ट रूप से पंजीकृत किया है, अब इसे संकलन चरण पर पहुँचा जा सकता है।

नियंत्रक में सेवाओं को जोड़ना।

कंटेनर और बंडलों के संकलन के चरण में, हम केवल सेवा परिभाषाओं के साथ काम कर सकते हैं। इस स्तर पर, हमें HealthController की परिभाषा लेने की आवश्यकता है और संकेत मिलता है कि इसके निर्माण के बाद यह आवश्यक है कि इसमें उन सभी सेवाओं को जोड़ा जाए जो हमारे टैग के साथ चिह्नित हैं। बंडलों में इस तरह के संचालन के लिए, इंटरफ़ेस को लागू करने वाले वर्ग जिम्मेदार हैं
Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface

निम्नलिखित src/DependencyInjection/Compiler/HealthServicePath.php बनाएँ:

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection\Compiler; use niklesh\HealthCheckBundle\Controller\HealthController; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Reference; class HealthServicesPath implements CompilerPassInterface { public function process(ContainerBuilder $container) { if (!$container->has(HealthController::class)) { return; } $controller = $container->findDefinition(HealthController::class); foreach (array_keys($container->findTaggedServiceIds(HealthInterface::TAG)) as $serviceId) { $controller->addMethodCall('addHealthService', [new Reference($serviceId)]); } } }

जैसा कि आप देख सकते हैं, हम पहले findDefinition पद्धति का उपयोग करके नियंत्रक लेते हैं, फिर - टैग द्वारा सभी सेवाएँ और फिर, एक लूप में, प्रत्येक सेवा के लिए addHealthService विधि में एक कॉल जोड़ते हैं, जहां हम इस सेवा के लिंक को पास करते हैं।

CompilerPath का उपयोग करना

अंतिम चरण हमारे HealthServicePath को बंडल संकलन प्रक्रिया में जोड़ना है। चलिए HealthCheckBundle क्लास में वापस HealthCheckBundle हैं और build विधि को थोड़ा और बदलते हैं। नतीजतन, हम प्राप्त करते हैं:

 <?php namespace niklesh\HealthCheckBundle; use niklesh\HealthCheckBundle\DependencyInjection\Compiler\HealthServicesPath; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\HttpKernel\Bundle\Bundle; class HealthCheckBundle extends Bundle { public function build(ContainerBuilder $container) { parent::build($container); $container->addCompilerPass(new HealthServicesPath()); $container->registerForAutoconfiguration(HealthInterface::class)->addTag(HealthInterface::TAG); } }

असल में, इस स्तर पर हमारा बंडल उपयोग के लिए तैयार है। यह सूचना संग्रह सेवाओं को ढूंढ सकता है, उनके साथ काम कर सकता है और संपर्क करने पर जवाब दे सकता है /health (आपको कनेक्ट करते समय केवल राउटिंग सेटिंग्स जोड़ने की आवश्यकता है), लेकिन मैंने इसमें केवल अनुरोध पर जानकारी भेजने की क्षमता ही नहीं, बल्कि यह जानकारी भेजने की क्षमता भी प्रदान की है। या, उदाहरण के लिए, एक POST अनुरोध या एक कतार प्रबंधक के माध्यम से।

HealthSenderInterface

इस इंटरफ़ेस का उद्देश्य कहीं न कहीं डेटा भेजने के लिए जिम्मेदार वर्गों का वर्णन करना है। इसे src/Service/HealthSenderInterface में बनाएँ

 <?php namespace niklesh\HealthCheckBundle\Service; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; interface HealthSenderInterface { /** * @param HealthDataInterface[] $data */ public function send(array $data): void; public function getDescription(): string; public function getName(): string; }

जैसा कि आप देख सकते हैं, send विधि किसी भी तरह से HealthInterface लागू करने वाले सभी वर्गों से प्राप्त डेटा सरणी को HealthInterface और फिर इसे उस स्थान पर भेज HealthInterface जहां इसकी आवश्यकता है।
कंसोल कमांड चलाते समय जानकारी प्रदर्शित करने के लिए getName और getName की आवश्यकता होती है।

SendDataCommand

थर्ड-पार्टी संसाधनों को डेटा भेजना शुरू करें कंसोल कमांड SendDataCommand । इसका कार्य वितरण के लिए डेटा एकत्र करना है, और फिर वितरण सेवाओं में से प्रत्येक पर send विधि को कॉल करना है। जाहिर है, यह कमांड नियंत्रक के तर्क को आंशिक रूप से दोहराएगा, लेकिन सब कुछ में नहीं।

 <?php namespace niklesh\HealthCheckBundle\Command; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; use niklesh\HealthCheckBundle\Service\HealthInterface; use niklesh\HealthCheckBundle\Service\HealthSenderInterface; use Symfony\Component\Console\Command\Command; use Symfony\Component\Console\Input\InputInterface; use Symfony\Component\Console\Output\OutputInterface; use Symfony\Component\Console\Style\SymfonyStyle; use Throwable; class SendDataCommand extends Command { public const COMMAND_NAME = 'health:send-info'; private $senders; /** @var HealthInterface[] */ private $healthServices; /** @var SymfonyStyle */ private $io; public function __construct(HealthSenderInterface... $senders) { parent::__construct(self::COMMAND_NAME); $this->senders = $senders; } public function addHealthService(HealthInterface $healthService) { $this->healthServices[] = $healthService; } protected function configure() { parent::configure(); $this->setDescription('Send health data by senders'); } protected function initialize(InputInterface $input, OutputInterface $output) { parent::initialize($input, $output); $this->io = new SymfonyStyle($input, $output); } protected function execute(InputInterface $input, OutputInterface $output) { $this->io->title('Sending health info'); try { $data = array_map(function (HealthInterface $service): HealthDataInterface { return $service->getHealthInfo(); }, $this->healthServices); foreach ($this->senders as $sender) { $this->outputInfo($sender); $sender->send($data); } $this->io->success('Data is sent by all senders'); } catch (Throwable $exception) { $this->io->error('Exception occurred: ' . $exception->getMessage()); $this->io->text($exception->getTraceAsString()); } } private function outputInfo(HealthSenderInterface $sender) { if ($name = $sender->getName()) { $this->io->writeln($name); } if ($description = $sender->getDescription()) { $this->io->writeln($description); } } }

HealthServicesPath , टीम को डेटा संग्रह सेवाओं के अलावा लिखते हैं।

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection\Compiler; use niklesh\HealthCheckBundle\Command\SendDataCommand; use niklesh\HealthCheckBundle\Controller\HealthController; use niklesh\HealthCheckBundle\Service\HealthInterface; use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Reference; class HealthServicesPath implements CompilerPassInterface { public function process(ContainerBuilder $container) { if (!$container->has(HealthController::class)) { return; } $controller = $container->findDefinition(HealthController::class); $commandDefinition = $container->findDefinition(SendDataCommand::class); foreach (array_keys($container->findTaggedServiceIds(HealthInterface::TAG)) as $serviceId) { $controller->addMethodCall('addHealthService', [new Reference($serviceId)]); $commandDefinition->addMethodCall('addHealthService', [new Reference($serviceId)]); } } }

जैसा कि आप देख सकते हैं, कंस्ट्रक्टर में कमांड प्रेषकों की एक सरणी को स्वीकार करता है। इस मामले में, आप निर्भरता ऑटो-बाइंडिंग सुविधा का उपयोग करने में सक्षम नहीं होंगे, हमें खुद एक टीम बनाने और पंजीकरण करने की आवश्यकता है। एकमात्र सवाल यह है कि इस कमांड को जोड़ने के लिए कौन सी प्रेषक सेवाएं हैं। हम बंडल विन्यास में उनकी आईडी को इस तरह इंगित करेंगे:

 health_check: senders: - '@sender.service1' - '@sender.service2'

हमारे बंडल अभी भी नहीं जानते कि इस तरह के कॉन्फ़िगरेशन को कैसे संभालना है, हम इसे सिखाएंगे। Configuration.php जाएँ। कॉन्फ़िगरेशन ट्री जोड़ें और जोड़ें:

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection; use Symfony\Component\Config\Definition\Builder\TreeBuilder; use Symfony\Component\Config\Definition\ConfigurationInterface; class Configuration implements ConfigurationInterface { public function getConfigTreeBuilder() { $treeBuilder = new TreeBuilder(); $rootNode = $treeBuilder->root('health_check'); $rootNode ->children() ->arrayNode('senders') ->scalarPrototype()->end() ->end() ->end() ; return $treeBuilder; } }

यह कोड निर्धारित करता है कि रूट नोड health_check नोड होगा, जिसमें senders सरणी senders , जिसमें बदले में एक निश्चित संख्या में लाइनें होंगी। यही है, अब हमारा बंडल जानता है कि कॉन्फ़िगरेशन को कैसे संभालना है, जिसे हमने ऊपर उल्लिखित किया है। टीम को पंजीकृत करने का समय आ गया है। ऐसा करने के लिए, HealthCheckExtension और निम्नलिखित कोड जोड़ें:

 <?php namespace niklesh\HealthCheckBundle\DependencyInjection; use niklesh\HealthCheckBundle\Command\SendDataCommand; use Symfony\Component\Config\FileLocator; use Symfony\Component\DependencyInjection\ContainerBuilder; use Symfony\Component\DependencyInjection\Definition; use Symfony\Component\HttpKernel\DependencyInjection\Extension; use Symfony\Component\DependencyInjection\Loader; use Symfony\Component\DependencyInjection\Reference; class HealthCheckExtension extends Extension { /** * {@inheritdoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yaml'); //    $commandDefinition = new Definition(SendDataCommand::class); //        foreach ($config['senders'] as $serviceId) { $commandDefinition->addArgument(new Reference($serviceId)); } //       $commandDefinition->addTag('console.command', ['command' => SendDataCommand::COMMAND_NAME]); //     $container->setDefinition(SendDataCommand::class, $commandDefinition); } }

यही है, हमारी टीम निर्धारित है। अब, प्रोजेक्ट को बंडल को जोड़ने के बाद, जब बुलाया जाता है
bin/console हम कमांड की एक सूची देखेंगे, जिसमें हमारा health:send-info , आप इसे उसी तरह से कॉल कर सकते हैं: bin/console health:send-info

हमारी पोटली तैयार है। यह परियोजना पर इसका परीक्षण करने का समय है। एक खाली प्रोजेक्ट बनाएं:

 composer create-project symfony/skeleton health-test-project

इसमें हमारे ताजे पके हुए बंडल को मिलाएं, इसके लिए हम composer.json खंड को composer.json में जोड़ते हैं। repositories :

 "repositories": [ { "type": "vcs", "url": "https://github.com/HEKET313/health-check" } ]

और कमांड निष्पादित करें:

 composer require niklesh/health-check

और भी, सबसे तेज शुरुआत के लिए, हमारी परियोजना में एक सिम्फनी सर्वर जोड़ें:

 composer req --dev server

बंडल जुड़ा हुआ है, सिम्फनी फ्लेक्स स्वचालित रूप से इसे config/bundles.php से जोड़ता है, लेकिन स्वचालित रूप से कॉन्फ़िगरेशन फ़ाइलों को बनाने के लिए, आपको एक नुस्खा बनाने की आवश्यकता है। व्यंजनों के बारे में यहां एक और लेख में खूबसूरती से चित्रित किया गया है: https://habr.com/post/345382/ - इसलिए व्यंजनों को कैसे बनाएं आदि पेंट करें। मैं यहां नहीं रहूंगा, और इस बंडल के लिए अभी तक कोई नुस्खा नहीं है।

फिर भी, कॉन्फ़िगरेशन फ़ाइलों की आवश्यकता है, इसलिए उन्हें हैंडल से बनाएं:

config/routes/niklesh_health.yaml

 health_check: resource: "@HealthCheckBundle/Controller/HealthController.php" prefix: / type: annotation

config/packages/hiklesh_health.yaml

 health_check: senders: - 'App\Service\Sender'

अब आपको टीम और सूचना संग्रह वर्ग के लिए सूचना भेजने की कक्षाओं को लागू करने की आवश्यकता है

src/Service/DataCollector.php

यहां सब कुछ बेहद सरल है।

 <?php namespace App\Service; use niklesh\HealthCheckBundle\Entity\CommonHealthData; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; use niklesh\HealthCheckBundle\Service\HealthInterface; class DataCollector implements HealthInterface { public function getName(): string { return 'Data collector'; } public function getHealthInfo(): HealthDataInterface { $data = new CommonHealthData(HealthDataInterface::STATUS_OK); $data->setAdditionalInfo(['some_data' => 'some_value']); return $data; } }

src/Service/Sender.php

और यहाँ यह और भी आसान है

 <?php namespace App\Service; use niklesh\HealthCheckBundle\Entity\HealthDataInterface; use niklesh\HealthCheckBundle\Service\HealthSenderInterface; class Sender implements HealthSenderInterface { /** * @param HealthDataInterface[] $data */ public function send(array $data): void { print "Data sent\n"; } public function getDescription(): string { return 'Sender description'; } public function getName(): string { return 'Sender name'; } }

हो गया! कैश साफ़ करें और सर्वर शुरू करें

 bin/console cache:clear bin/console server:start

अब आप हमारी टीम को आजमा सकते हैं:

 bin/console health:send-info

हमें ऐसा सुंदर निष्कर्ष मिलता है:

अंत में, हम अपने मार्ग http://127.0.0.1:8000/health पर दस्तक देते हैं और एक कम सुंदर, लेकिन यह भी निष्कर्ष निकालते हैं:

 [{"name":"Data collector","info":{"status":1,"additional_info":{"some_data":"some_value"}}}]

वह सब है! मुझे उम्मीद है कि यह सीधा ट्यूटोरियल किसी को सिम्फनी 4 के लिए बंडल लिखने की मूल बातें समझने में मदद करता है।

PS स्रोत कोड यहां उपलब्ध है ।

Symfony 4 चरण के लिए एक बंडल बनाएं