C++ ലെ മൈക്രോസർവീസുകൾ. ഫിക്ഷനോ യാഥാർത്ഥ്യമോ?

ഈ ലേഖനത്തിൽ ഞാൻ എങ്ങനെ ഒരു ടെംപ്ലേറ്റ് (കുക്കികട്ടർ) സൃഷ്ടിച്ചുവെന്നും ഡോക്കർ/ഡോക്കർ-കമ്പോസും കോനൻ പാക്കേജ് മാനേജറും ഉപയോഗിച്ച് C++ ൽ ഒരു REST API സേവനം എഴുതുന്നതിനുള്ള ഒരു അന്തരീക്ഷം എങ്ങനെ സജ്ജീകരിച്ചുവെന്നും സംസാരിക്കും.

ഒരു ബാക്കെൻഡ് ഡെവലപ്പറായി ഞാൻ പങ്കെടുത്ത അടുത്ത ഹാക്കത്തണിൽ, അടുത്ത മൈക്രോസർവീസ് എഴുതാൻ എന്ത് ഉപയോഗിക്കണം എന്ന ചോദ്യം ഉയർന്നു. ഇതുവരെ എഴുതിയതെല്ലാം ഞാനും ഞാനും ചേർന്ന് എഴുതിയതാണ് സഖാവ് പൈത്തണിൽ, എന്റെ സഹപ്രവർത്തകൻ ഈ മേഖലയിൽ വിദഗ്ദ്ധനും പ്രൊഫഷണലായി വികസിപ്പിച്ച ബാക്കെൻഡുകളും ആയതിനാൽ, ഞാൻ പൊതുവെ ഒരു എംബഡഡ് സിസ്റ്റം ഡെവലപ്പറായിരിക്കെ, മഹത്തായതും ഭയങ്കരവുമായ C++ ൽ എഴുതുകയും, ഞാൻ യൂണിവേഴ്സിറ്റിയിൽ നിന്ന് പൈത്തൺ പഠിക്കുകയും ചെയ്തു.

അതിനാൽ, ഉയർന്ന ലോഡ് സേവനം എഴുതാനുള്ള ചുമതല ഞങ്ങൾ അഭിമുഖീകരിച്ചു, അതിലേക്ക് വരുന്ന ഡാറ്റ മുൻകൂട്ടി പ്രോസസ്സ് ചെയ്യുകയും ഡാറ്റാബേസിലേക്ക് എഴുതുകയും ചെയ്യുക എന്നതായിരുന്നു പ്രധാന ചുമതല. മറ്റൊരു സ്മോക്ക് ബ്രേക്കിന് ശേഷം, ഒരു C++ ഡെവലപ്പർ എന്ന നിലയിൽ, പ്രോസ് ഉപയോഗിച്ച് ഈ സേവനം എഴുതാൻ ഒരു സുഹൃത്ത് നിർദ്ദേശിച്ചു. ഇത് വേഗമേറിയതും കൂടുതൽ ഉൽപ്പാദനക്ഷമതയുള്ളതുമായിരിക്കും, പൊതുവേ, ടീമിന്റെ വിഭവങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് ഞങ്ങൾക്ക് അറിയാമെന്നതിൽ ജൂറി സന്തോഷിക്കും. അതിന് ഞാൻ C++-ൽ ഒരിക്കലും ഇത്തരം കാര്യങ്ങൾ ചെയ്തിട്ടില്ലെന്നും ബാക്കിയുള്ള 20+ മണിക്കൂർ അനുയോജ്യമായ ലൈബ്രറികൾ തിരയുന്നതിനും കംപൈൽ ചെയ്യുന്നതിനും ലിങ്ക് ചെയ്യുന്നതിനും എളുപ്പത്തിൽ വിനിയോഗിക്കാമെന്നും ഞാൻ മറുപടി നൽകി. ലളിതമായി പറഞ്ഞാൽ, ഞാൻ കോഴിയിറച്ചി. അതാണ് ഞങ്ങൾ തീരുമാനിച്ചതും ശാന്തമായി പൈത്തണിൽ എല്ലാം പൂർത്തിയാക്കിയതും.

ഇപ്പോൾ, നിർബന്ധിത സ്വയം ഒറ്റപ്പെടൽ സമയത്ത്, C++ ൽ സേവനങ്ങൾ എങ്ങനെ എഴുതാമെന്ന് കണ്ടുപിടിക്കാൻ ഞാൻ തീരുമാനിച്ചു. അനുയോജ്യമായ ലൈബ്രറി തീരുമാനിക്കുകയായിരുന്നു ആദ്യം ചെയ്യേണ്ടത്. എന്റെ തിരഞ്ഞെടുപ്പ് വീണു സ്നേഹശലഭം, ഇത് ഒബ്ജക്റ്റ് ഓറിയന്റഡ് ശൈലിയിൽ എഴുതിയതിനാൽ സാധാരണ ഡോക്യുമെന്റേഷനും പ്രശംസനീയമാണ്. കൂടാതെ, ഒരു അസംബ്ലി സംവിധാനം തിരഞ്ഞെടുക്കുന്നതിനെക്കുറിച്ച് ചോദ്യം ഉയർന്നു. ഈ സമയം വരെ ഞാൻ വിഷ്വൽ സ്റ്റുഡിയോ, IAR, വെറും മേക്ക് ഫയലുകൾ എന്നിവയിൽ മാത്രമേ പ്രവർത്തിച്ചിട്ടുള്ളൂ. ഈ സംവിധാനങ്ങളൊന്നും എന്നെ ആകർഷിച്ചില്ല, കാരണം മുഴുവൻ സേവനവും ഒരു ഡോക്കർ കണ്ടെയ്‌നറിൽ പ്രവർത്തിപ്പിക്കാൻ ഞാൻ പദ്ധതിയിട്ടിരുന്നു. അപ്പോൾ ഞാൻ cmake ഉം രസകരമായ ഒരു പാക്കേജ് മാനേജറും കണ്ടുപിടിക്കാൻ ശ്രമിക്കാൻ തീരുമാനിച്ചു കോനൻ. എല്ലാ ഡിപൻഡൻസികളും ഒരു ഫയലിൽ രജിസ്റ്റർ ചെയ്യാൻ ഈ പാക്കേജ് മാനേജർ നിങ്ങളെ അനുവദിച്ചു

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-നൊപ്പം പ്രവർത്തിക്കാൻ ഞാൻ ഒരു ലൈബ്രറി തിരയാൻ തുടങ്ങി, കാരണം എനിക്ക് ജോലി പരിചയം കുറവായിരുന്നു, ഞങ്ങളുടെ പൈത്തൺ സേവനങ്ങളുമായി സംവദിച്ചതും ഇതായിരുന്നു. പിന്നെ ഞാൻ എന്താണ് പഠിച്ചതെന്ന് നിങ്ങൾക്കറിയാമോ? ഇത് 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 നിർവഹിക്കുന്നതിന്, ഒരു രീതിയുണ്ട് ExecuteSQL(). കൂടുതൽ സങ്കീർണ്ണമായ അന്വേഷണങ്ങൾക്കോ ​​ഡാറ്റ വീണ്ടെടുക്കലിനോ, നിങ്ങൾ വഴി ഒരു കണക്ഷൻ നേടേണ്ടതുണ്ട് ഗെറ്റ്കണക്ഷൻ() കൂടാതെ 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

നിങ്ങൾക്ക് എല്ലാ കോഡും ഇവിടെ കാണാം ഗിത്തബ്.

ഇപ്പോൾ dockerfile, docker-compose.yml എന്നിവ എഴുതുന്നതിന്റെ അവസാന ഘട്ടം വരുന്നു. സത്യം പറഞ്ഞാൽ, ഇതിന് കൂടുതൽ സമയമെടുത്തു, ഞാൻ ഒരു നോബായതിനാൽ മാത്രമല്ല, ഓരോ തവണയും ലൈബ്രറികൾ പുനർനിർമ്മിക്കേണ്ടത് ആവശ്യമായിരുന്നു, മറിച്ച് കോനന്റെ കുഴപ്പങ്ങൾ കാരണം. ഉദാഹരണത്തിന്, conan ഡൗൺലോഡ് ചെയ്യുന്നതിനും ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനും ആവശ്യമായ ഡിപൻഡൻസികൾ നിർമ്മിക്കുന്നതിനും, അത് “conan install .” ഡൗൺലോഡ് ചെയ്‌താൽ പോരാ, അത് -s compiler.libcxx=libstdc++11 പാരാമീറ്റർ കൂടി നൽകേണ്ടതുണ്ട്, അല്ലാത്തപക്ഷം നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ലിങ്ക് ചെയ്യുന്ന ഘട്ടത്തിൽ നിങ്ങൾക്ക് ഒരു കൂട്ടം പിശകുകൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. കുറച്ച് മണിക്കൂറുകളായി ഞാൻ ഈ പിശകിൽ കുടുങ്ങിക്കിടക്കുകയാണ്, കുറഞ്ഞ സമയത്തിനുള്ളിൽ ഈ പ്രശ്നം പരിഹരിക്കാൻ ഈ ലേഖനം മറ്റുള്ളവരെ സഹായിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

അടുത്തതായി, docker-compose.yml എഴുതിയ ശേഷം, എന്റെ സുഹൃത്തിന്റെ ഉപദേശപ്രകാരം, ഞാൻ പിന്തുണ ചേർത്തു കുക്കി മുറിക്കുന്ന കൺസോളിൽ "cookiecutter" എന്ന് നൽകിക്കൊണ്ട്, ഇഷ്‌ടാനുസൃതമാക്കിയ പരിതസ്ഥിതിയും PostgreSQL ഇൻസ്റ്റാളുമുള്ള C++-ൽ ഒരു REST API സേവനത്തിനായി ഇപ്പോൾ നിങ്ങൾക്ക് ഒരു പൂർണ്ണമായ ടെംപ്ലേറ്റ് സ്വന്തമാക്കാം. https://github.com/KovalevVasiliy/cpp_rest_api_template.git" തുടർന്ന് "ഡോക്കർ-കംപോസ് അപ്പ് -ബിൽഡ്".

മികച്ചതും ശക്തവുമായ, എന്നാൽ C++ പോലുള്ള വിചിത്രമായ ഭാഷയിൽ REST API ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിനുള്ള ബുദ്ധിമുട്ടുള്ള പാതയിൽ തുടക്കക്കാർക്ക് ഈ ടെംപ്ലേറ്റ് സഹായിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.
കൂടാതെ, ഇവിടെ വായിക്കാൻ ഞാൻ വളരെ ശുപാർശ ചെയ്യുന്നു ഇത് ലേഖനം. POCO ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാമെന്നും നിങ്ങളുടെ സ്വന്തം REST API സേവനം എങ്ങനെ എഴുതാമെന്നും ഇത് കൂടുതൽ വിശദമായി വിശദീകരിക്കുന്നു.

അവലംബം: www.habr.com