მიკროსერვისები C++-ში. ფიქცია თუ რეალობა?

ამ სტატიაში ვისაუბრებ იმაზე, თუ როგორ შევქმენი შაბლონი (ქუქი-ფაილები) და დავაყენე გარემო C++-ში REST API სერვისის დასაწერად docker/docker-compose-ის და კონანის პაკეტის მენეჯერის გამოყენებით.

შემდეგი ჰაკათონის დროს, რომელშიც მე მივიღე მონაწილეობა, როგორც ბექენდის დეველოპერი, გაჩნდა კითხვა, რა გამოვიყენო შემდეგი მიკროსერვისის დასაწერად. რაც აქამდე დაიწერა ყველაფერი მე და ჩემი დავწერე ამხანაგი პითონში, რადგან ჩემი კოლეგა იყო ამ დარგის ექსპერტი და პროფესიონალურად ავითარებდა ბექენდებს, მე კი ზოგადად ჩაშენებული სისტემების დეველოპერი ვიყავი და ვწერდი დიდ და საშინელ C++-ში, ხოლო პითონი ახლახან ვისწავლე უნივერსიტეტში.

ასე რომ, ჩვენ დაგვხვდა მაღალი დატვირთვის სერვისის დაწერის ამოცანა, რომლის მთავარი ამოცანა იყო მასში შემოსული მონაცემების წინასწარ დამუშავება და მონაცემთა ბაზაში ჩაწერა. და მორიგი კვამლის შესვენების შემდეგ, მეგობარმა შემომთავაზა, რომ მე, როგორც C++ დეველოპერმა, დამეწერა ეს სერვისი პროფესიონალთა გამოყენებით. ამის მტკიცება არის ის, რომ ეს იქნება უფრო სწრაფი, უფრო პროდუქტიული და ზოგადად, ჟიური აღფრთოვანებული იქნება იმით, თუ როგორ ვიცით როგორ ვმართოთ გუნდის რესურსები. რაზეც მე ვუპასუხე, რომ არასდროს გამიკეთებია მსგავსი რამ C++-ში და ადვილად შემეძლო დარჩენილ 20+ საათს დავთმოდი შესაბამისი ბიბლიოთეკების ძიებას, შედგენასა და დაკავშირებას. მარტივად რომ ვთქვათ, მე დავტოვე. სწორედ ეს გადავწყვიტეთ და მშვიდად დავასრულეთ ყველაფერი პითონში.

ახლა, იძულებითი თვითიზოლაციის დროს, გადავწყვიტე გამეგო, როგორ დავწერო სერვისები C++-ში. პირველი რაც უნდა გაეკეთებინა იყო შესაფერისი ბიბლიოთეკის არჩევა. ჩემი არჩევანი დაეცა POCO, ვინაიდან იგი დაწერილი იყო ობიექტზე ორიენტირებულ სტილში და ასევე იწონებდა ნორმალურ დოკუმენტაციას. ასევე, გაჩნდა კითხვა ასამბლეის სისტემის არჩევის შესახებ. ამ მომენტამდე მე მხოლოდ Visual Studio-სთან, IAR-თან და შიშველ მაკეფაილებთან მიმუშავია. და არცერთი ეს სისტემა არ მომხიბლავდა, რადგან მე ვგეგმავდი მთელი სერვისის გაშვებას დოკერის კონტეინერში. შემდეგ გადავწყვიტე გამომეკვლია cmake და საინტერესო პაკეტის მენეჯერი conan. ამ პაკეტის მენეჯერმა საშუალებას მოგცემთ დაარეგისტრიროთ ყველა დამოკიდებულება ერთ ფაილში

conanfile.txt
[მოითხოვს] poco/1.9.3
libpq/11.5

[გენერატორები] cmake

და მარტივი ბრძანებით "conan install ." დააინსტალირეთ საჭირო ბიბლიოთეკები. ბუნებრივია, ასევე აუცილებელი იყო ცვლილებების შეტანა

CMakeLists.txt

include(build/conanbuildinfo.cmake)
conan_basic_setup()
target_link_libraries(<target_name> ${CONAN_LIBS})

ამის შემდეგ დავიწყე ბიბლიოთეკის ძებნა PostgreSQL-თან მუშაობისთვის, რადგან ეს იყო ბიბლიოთეკა, რომელთანაც მუშაობის მცირე გამოცდილება მქონდა და ასევე იყო ის, რომლებთანაც ჩვენი Python სერვისები ურთიერთობდნენ. და იცი რა ვისწავლე? ის POCO-შია! მაგრამ კონანმა არ იცის, რომ ის არის POCO-ში და არ იცის როგორ ააშენოს იგი; საცავში არის მოძველებული კონფიგურაციის ფაილი (ამ შეცდომის შესახებ უკვე დავწერე POCO-ს შემქმნელებს). ეს ნიშნავს, რომ თქვენ მოგიწევთ სხვა ბიბლიოთეკის ძებნა.

შემდეგ კი ჩემი არჩევანი ნაკლებად პოპულარულ ბიბლიოთეკაზე დაეცა libpg. მე კი წარმოუდგენლად გამიმართლა, ის უკვე კონანში იყო და აწყობილი და აწყობილიც კი იყო.

შემდეგი ნაბიჯი იყო სერვისის შაბლონის დაწერა, რომელსაც შეუძლია მოთხოვნების დამუშავება.
ჩვენ უნდა მემკვიდრეობით მივიღოთ ჩვენი TemplateServerApp კლასი Poco::Util::ServerApplication-დან და გავაუქმოთ ძირითადი მეთოდი.

TemplateServerApp

#pragma once

#include <string>
#include <vector>
#include <Poco/Util/ServerApplication.h>

class TemplateServerApp : public Poco::Util::ServerApplication
{
    protected:
        int main(const std::vector<std::string> &);
};

int TemplateServerApp::main(const vector<string> &)
{
    HTTPServerParams* pParams = new HTTPServerParams;

    pParams->setMaxQueued(100);
    pParams->setMaxThreads(16);

    HTTPServer s(new TemplateRequestHandlerFactory, ServerSocket(8000), pParams);

    s.start();
    cerr << "Server started" << endl;

    waitForTerminationRequest();  // wait for CTRL-C or kill

    cerr << "Shutting down..." << endl;
    s.stop();

    return Application::EXIT_OK;
}

მთავარ მეთოდში უნდა დავაყენოთ პარამეტრები: პორტი, ძაფების რაოდენობა და რიგის ზომა. და რაც მთავარია, თქვენ უნდა მიუთითოთ დამმუშავებელი შემომავალი მოთხოვნებისთვის. ეს კეთდება ქარხნის შექმნით

TemplateRequestHandlerFactory

class TemplateRequestHandlerFactory : public HTTPRequestHandlerFactory
{
public:
    virtual HTTPRequestHandler* createRequestHandler(const HTTPServerRequest & request)
    {
        return new TemplateServerAppHandler;
    }
};

ჩემს შემთხვევაში, ის უბრალოდ ყოველ ჯერზე ქმნის ერთსა და იმავე დამმუშავებელს - TemplateServerAppHandler. სწორედ აქ შეგვიძლია განვათავსოთ ჩვენი ბიზნეს ლოგიკა.

TemplateServerAppHandler

class TemplateServerAppHandler : public HTTPRequestHandler
{
public:
    void handleRequest(HTTPServerRequest &req, HTTPServerResponse &resp)
    {
        URI uri(req.getURI());
        string method = req.getMethod();

        cerr << "URI: " << uri.toString() << endl;
        cerr << "Method: " << req.getMethod() << endl;

        StringTokenizer tokenizer(uri.getPath(), "/", StringTokenizer::TOK_TRIM);
        HTMLForm form(req,req.stream());

        if(!method.compare("POST"))
        {
            cerr << "POST" << endl;
        }
        else if(!method.compare("PUT"))
        {
            cerr << "PUT" << endl;
        }
        else if(!method.compare("DELETE"))
        {
            cerr << "DELETE" << endl;
        }

        resp.setStatus(HTTPResponse::HTTP_OK);
        resp.setContentType("application/json");
        ostream& out = resp.send();

        out << "{"hello":"heh"}" << endl;
        out.flush();
    }
};

მე ასევე შევქმენი კლასის შაბლონი PostgreSQL-თან მუშაობისთვის. მარტივი SQL-ის შესასრულებლად, როგორიცაა ცხრილის შექმნა, არსებობს მეთოდი ExecuteSQL(). უფრო რთული მოთხოვნების ან მონაცემების მისაღებად, თქვენ მოგიწევთ კავშირის მიღება GetConnection () და გამოიყენეთ libpg API. (ალბათ მოგვიანებით გამოვასწორებ ამ უსამართლობას).

მონაცემთა ბაზა

#pragma once

#include <memory>
#include <mutex>
#include <libpq-fe.h>

class Database
{
public:
    Database();
    std::shared_ptr<PGconn> GetConnection() const;
    bool ExecuteSQL(const std::string& sql);

private:
    void establish_connection();
    void LoadEnvVariables();

    std::string m_dbhost;
    int         m_dbport;
    std::string m_dbname;
    std::string m_dbuser;
    std::string m_dbpass;

    std::shared_ptr<PGconn>  m_connection;
};

მონაცემთა ბაზასთან დაკავშირების ყველა პარამეტრი აღებულია გარემოდან, ასე რომ თქვენ ასევე გჭირდებათ .env ფაილის შექმნა და კონფიგურაცია.

.ენვ

DATABASE_NAME=template
DATABASE_USER=user
DATABASE_PASSWORD=password
DATABASE_HOST=postgres
DATABASE_PORT=5432

თქვენ შეგიძლიათ ნახოთ ყველა კოდი აქ github.

და ახლა მოდის dockerfile და docker-compose.yml დაწერის ბოლო ეტაპი. მართალი გითხრათ, ამას ყველაზე მეტი დრო დასჭირდა და არა მხოლოდ იმიტომ, რომ მე ვარ ნობი, რადგან საჭირო იყო ყოველ ჯერზე ბიბლიოთეკების აღდგენა, არამედ კონანის ხარვეზების გამო. მაგალითად, იმისათვის, რომ Conan-მა ჩამოტვირთოს, დააინსტალიროს და ააშენოს საჭირო დამოკიდებულებები, არ არის საკმარისი იმისათვის, რომ გადმოწეროს “conan install .”, მან ასევე უნდა გაიაროს -s compiler.libcxx=libstdc++11 პარამეტრი, წინააღმდეგ შემთხვევაში. თქვენი განაცხადის დაკავშირების ეტაპზე თქვენ რისკავთ შეცდომების თაიგულის მიღებას. მე რამდენიმე საათის განმავლობაში დავრჩი ამ შეცდომით და იმედი მაქვს, რომ ეს სტატია დაეხმარება სხვა ადამიანებს ამ პრობლემის მოგვარებაში ნაკლებ დროში.

შემდეგ, docker-compose.yml-ის დაწერის შემდეგ, ჩემი მეგობრის რჩევით, დავამატე მხარდაჭერა ფუნთუშა კატარღა და ახლა თქვენ შეგიძლიათ მიიღოთ სრულფასოვანი შაბლონი REST API სერვისისთვის C++-ში, მორგებული გარემოთი და დაინსტალირებული PostgreSQL, უბრალოდ კონსოლში „ქუქი-ფაილების“ შეყვანით. https://github.com/KovalevVasiliy/cpp_rest_api_template.git" და შემდეგ "დოკერ-კომპოზიცია - აშენება".

იმედი მაქვს, რომ ეს შაბლონი დაეხმარება დამწყებთათვის REST API აპლიკაციების შემუშავების რთულ გზაზე დიდ და ძლიერ, მაგრამ ისეთ მოუხერხებელ ენაზე, როგორიცაა C++.
ასევე, გირჩევთ აქ წაიკითხოთ ეს სტატია. იგი უფრო დეტალურად განმარტავს, თუ როგორ უნდა იმუშაოთ POCO-სთან და დაწეროთ თქვენი REST API სერვისი.

წყარო: www.habr.com