C++ માં માઇક્રોસર્વિસિસ. કાલ્પનિક કે વાસ્તવિકતા?

આ લેખમાં હું તે વિશે વાત કરીશ કે મેં કેવી રીતે ટેમ્પલેટ (કુકીકટર) બનાવ્યું અને ડોકર/ડોકર-કંપોઝ અને કોનન પેકેજ મેનેજરનો ઉપયોગ કરીને C++ માં REST API સેવા લખવા માટે વાતાવરણ સેટ કર્યું.

આગામી હેકાથોન દરમિયાન, જેમાં મેં બેકએન્ડ ડેવલપર તરીકે ભાગ લીધો હતો, ત્યારે પ્રશ્ન ઊભો થયો કે આગામી માઇક્રોસર્વિસ લખવા માટે શું વાપરવું. અત્યાર સુધી જે કંઈ લખાયું છે તે બધું મારા અને મારા દ્વારા જ લખાયું છે સાથી Python માં, કારણ કે મારો સાથીદાર આ ક્ષેત્રમાં નિષ્ણાત હતો અને વ્યવસાયિક રીતે બેકએન્ડ્સ વિકસાવ્યા હતા, જ્યારે હું સામાન્ય રીતે એમ્બેડેડ સિસ્ટમ્સ ડેવલપર હતો અને મહાન અને ભયંકર C++ માં લખતો હતો, અને હું યુનિવર્સિટીમાં પાયથોન શીખ્યો હતો.

તેથી, અમને ઉચ્ચ-લોડ સેવા લખવાના કાર્યનો સામનો કરવો પડ્યો, જેનું મુખ્ય કાર્ય તેની પાસે આવતા ડેટાને પ્રીપ્રોસેસ કરવાનું હતું અને તેને ડેટાબેઝમાં લખવાનું હતું. અને બીજા ધુમાડાના વિરામ પછી, એક મિત્રએ સૂચવ્યું કે હું, C++ વિકાસકર્તા તરીકે, ગુણોનો ઉપયોગ કરીને આ સેવા લખું છું. આની દલીલ એ છે કે તે ઝડપી, વધુ ઉત્પાદક હશે અને સામાન્ય રીતે, ટીમના સંસાધનોનું સંચાલન કેવી રીતે કરવું તે અમે જાણીએ છીએ તેનાથી જ્યુરી ખુશ થશે. જેના પર મેં જવાબ આપ્યો કે મેં ક્યારેય C++ માં આવી વસ્તુઓ કરી નથી અને બાકીના 20+ કલાકો સરળતાથી યોગ્ય લાઇબ્રેરીઓ શોધવા, કમ્પાઇલ કરવા અને લિંક કરવા માટે ફાળવી શકું છું. સરળ શબ્દોમાં કહીએ તો, હું બહાર ચિકન. તે જ અમે નક્કી કર્યું અને શાંતિથી પાયથોનમાં બધું પૂર્ણ કર્યું.

હવે, ફરજિયાત સ્વ-અલગતા દરમિયાન, મેં C++ માં સેવાઓ કેવી રીતે લખવી તે શોધવાનું નક્કી કર્યું. પ્રથમ વસ્તુ એ હતી કે યોગ્ય પુસ્તકાલય નક્કી કરવું. મારી પસંદગી પર પડી બીઆઈટી, કારણ કે તે ઑબ્જેક્ટ-ઓરિએન્ટેડ શૈલીમાં લખવામાં આવ્યું હતું અને સામાન્ય દસ્તાવેજીકરણની પણ બડાઈ કરી હતી. ઉપરાંત, એસેમ્બલી સિસ્ટમ પસંદ કરવા અંગે પ્રશ્ન ઊભો થયો હતો. અત્યાર સુધી મેં વિઝ્યુઅલ સ્ટુડિયો, IAR અને એકદમ મેકફાઈલ્સ સાથે જ કામ કર્યું છે. અને આમાંથી કોઈ પણ સિસ્ટમે મને અપીલ કરી નથી, કારણ કે મેં આખી સેવાને ડોકર કન્ટેનરમાં ચલાવવાની યોજના બનાવી છે. પછી મેં cmake અને એક રસપ્રદ પેકેજ મેનેજરને શોધવાનો પ્રયાસ કરવાનું નક્કી કર્યું કોનન. આ પેકેજ મેનેજર તમને બધી નિર્ભરતાઓને એક ફાઈલમાં રજીસ્ટર કરવાની મંજૂરી આપે છે

conanfile.txt
[જરૂરી છે]poco/1.9.3
libpq/11.5

[જનરેટર] cmake

અને સરળ આદેશ સાથે "કોનન ઇન્સ્ટોલ કરો." જરૂરી પુસ્તકાલયો સ્થાપિત કરો. સ્વાભાવિક રીતે, તેમાં ફેરફાર કરવા પણ જરૂરી હતા

CMakeLists.txt

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

તે પછી, મેં PostgreSQL સાથે કામ કરવા માટે એક લાઇબ્રેરી શોધવાનું શરૂ કર્યું, કારણ કે તે એક એવી હતી જેની સાથે મને કામ કરવાનો થોડો અનુભવ હતો, અને તે અમારી પાયથોન સેવાઓ સાથે વાર્તાલાપ કરતી હતી. અને તમે જાણો છો કે હું શું શીખ્યો? તે POCO માં છે! પરંતુ કોનન જાણતો નથી કે તે POCO માં છે અને તેને કેવી રીતે બનાવવું તે ખબર નથી; રીપોઝીટરીમાં એક જૂની રૂપરેખાંકન ફાઇલ છે (મેં આ ભૂલ વિશે POCO ના નિર્માતાઓને પહેલેથી જ લખ્યું છે). આનો અર્થ એ કે તમારે બીજી લાઇબ્રેરી શોધવી પડશે.

અને પછી મારી પસંદગી ઓછી લોકપ્રિય પુસ્તકાલય પર પડી libpg. અને હું અતિ નસીબદાર હતો, તે પહેલેથી જ કોનનમાં હતો અને એસેમ્બલ અને એસેમ્બલ પણ થઈ રહ્યો હતો.

આગળનું પગલું એ સર્વિસ ટેમ્પલેટ લખવાનું હતું જે વિનંતીઓ પર પ્રક્રિયા કરી શકે.
આપણે Poco::Util::ServerApplication માંથી અમારા TemplateServerApp વર્ગને વારસામાં મેળવવો જોઈએ અને મુખ્ય પદ્ધતિને ઓવરરાઈડ કરવી જોઈએ.

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 કરવા માટે, જેમ કે ટેબલ બનાવવા માટે, ત્યાં એક પદ્ધતિ છે એક્ઝિક્યુટએસક્યુએલ(). વધુ જટિલ પ્રશ્નો અથવા ડેટા પુનઃપ્રાપ્તિ માટે, તમારે મારફતે કનેક્શન મેળવવું પડશે કનેક્શન મેળવો() અને 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 ફાઇલ બનાવવાની અને ગોઠવવાની પણ જરૂર છે.

.env

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

તમે બધા કોડ પર જોઈ શકો છો ગીથબ

અને હવે dockerfile અને docker-compose.yml લખવાનો અંતિમ તબક્કો આવે છે. સાચું કહું તો, આમાં મોટાભાગનો સમય લાગ્યો, અને માત્ર એટલા માટે જ નહીં કે હું નૂબ છું, કારણ કે દર વખતે પુસ્તકાલયોનું પુનઃનિર્માણ કરવું જરૂરી હતું, પરંતુ કોનનની મુશ્કેલીઓને કારણે. ઉદાહરણ તરીકે, કોનન ડાઉનલોડ કરવા, ઇન્સ્ટોલ કરવા અને જરૂરી નિર્ભરતા બનાવવા માટે, તેના માટે "કોનન ઇન્સ્ટોલ" ડાઉનલોડ કરવા માટે તે પૂરતું નથી, તેને -s compiler.libcxx=libstdc++11 પેરામીટર પણ પસાર કરવાની જરૂર છે, અન્યથા તમારી અરજીને લિંક કરવાના તબક્કે તમને ઘણી બધી ભૂલો મળવાનું જોખમ રહે છે. હું ઘણા કલાકોથી આ ભૂલથી અટવાઈ ગયો છું અને મને આશા છે કે આ લેખ અન્ય લોકોને ઓછા સમયમાં આ સમસ્યા હલ કરવામાં મદદ કરશે.

આગળ, docker-compose.yml લખ્યા પછી, મારા મિત્રની સલાહ પર, મેં આધાર ઉમેર્યો કૂકીકટર અને હવે તમે કન્સોલમાં ફક્ત "કુકીકટર" દાખલ કરીને, કસ્ટમાઇઝ્ડ પર્યાવરણ સાથે, C++ માં REST API સેવા માટે સંપૂર્ણ ટેમ્પલેટ મેળવી શકો છો અને PostgreSQL ઇન્સ્ટોલ કરી શકો છો. https://github.com/KovalevVasiliy/cpp_rest_api_template.git" અને પછી “ડોકર-કંપોઝ અપ —બિલ્ડ”.

હું આશા રાખું છું કે આ ટેમ્પ્લેટ નવા નિશાળીયાને REST API એપ્લીકેશન બનાવવાના તેમના મુશ્કેલ માર્ગ પર મહાન અને શક્તિશાળી, પરંતુ C++ જેવી અણઘડ ભાષામાં મદદ કરશે.
ઉપરાંત, હું અહીં વાંચવાની ખૂબ ભલામણ કરું છું આ લેખ તે વધુ વિગતવાર સમજાવે છે કે કેવી રીતે POCO સાથે કામ કરવું અને તમારી પોતાની REST API સેવા કેવી રીતે લખવી.

સોર્સ: www.habr.com