C++ ನಲ್ಲಿ ಸೂಕ್ಷ್ಮ ಸೇವೆಗಳು. ಫಿಕ್ಷನ್ ಅಥವಾ ರಿಯಾಲಿಟಿ?

ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ಟೆಂಪ್ಲೇಟ್ (ಕುಕಿಕಟರ್) ಅನ್ನು ಹೇಗೆ ರಚಿಸಿದ್ದೇನೆ ಮತ್ತು ಡಾಕರ್/ಡಾಕರ್-ಕಂಪೋಸ್ ಮತ್ತು ಕಾನನ್ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು C++ ನಲ್ಲಿ REST API ಸೇವೆಯನ್ನು ಬರೆಯಲು ಪರಿಸರವನ್ನು ಹೇಗೆ ಹೊಂದಿಸಿದೆ ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡುತ್ತೇನೆ.

ನಾನು ಬ್ಯಾಕೆಂಡ್ ಡೆವಲಪರ್ ಆಗಿ ಭಾಗವಹಿಸಿದ ಮುಂದಿನ ಹ್ಯಾಕಥಾನ್ ಸಮಯದಲ್ಲಿ, ಮುಂದಿನ ಮೈಕ್ರೋಸರ್ವಿಸ್ ಅನ್ನು ಬರೆಯಲು ಏನು ಬಳಸಬೇಕು ಎಂಬ ಪ್ರಶ್ನೆ ಉದ್ಭವಿಸಿತು. ಇಲ್ಲಿಯವರೆಗೆ ಬರೆದದ್ದೆಲ್ಲವೂ ನಾನು ಮತ್ತು ನನ್ನವರು ಬರೆದದ್ದು ಒಡನಾಡಿ ಪೈಥಾನ್‌ನಲ್ಲಿ, ನನ್ನ ಸಹೋದ್ಯೋಗಿಯು ಈ ಕ್ಷೇತ್ರದಲ್ಲಿ ಪರಿಣಿತನಾಗಿದ್ದರಿಂದ ಮತ್ತು ವೃತ್ತಿಪರವಾಗಿ ಬ್ಯಾಕೆಂಡ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ್ದರಿಂದ, ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ಎಂಬೆಡೆಡ್ ಸಿಸ್ಟಮ್ಸ್ ಡೆವಲಪರ್ ಆಗಿದ್ದಾಗ ಮತ್ತು ದೊಡ್ಡ ಮತ್ತು ಭಯಾನಕ C++ ನಲ್ಲಿ ಬರೆದಿದ್ದೇನೆ ಮತ್ತು ನಾನು ವಿಶ್ವವಿದ್ಯಾನಿಲಯದಲ್ಲಿ ಪೈಥಾನ್ ಅನ್ನು ಕಲಿತಿದ್ದೇನೆ.

ಆದ್ದರಿಂದ, ಹೆಚ್ಚಿನ-ಲೋಡ್ ಸೇವೆಯನ್ನು ಬರೆಯುವ ಕಾರ್ಯವನ್ನು ನಾವು ಎದುರಿಸಿದ್ದೇವೆ, ಅದರ ಮುಖ್ಯ ಕಾರ್ಯವೆಂದರೆ ಅದಕ್ಕೆ ಬರುವ ಡೇಟಾವನ್ನು ಪೂರ್ವಭಾವಿಯಾಗಿ ಸಂಸ್ಕರಿಸುವುದು ಮತ್ತು ಅದನ್ನು ಡೇಟಾಬೇಸ್ಗೆ ಬರೆಯುವುದು. ಮತ್ತು ಮತ್ತೊಂದು ಹೊಗೆ ವಿರಾಮದ ನಂತರ, ನಾನು C++ ಡೆವಲಪರ್ ಆಗಿ, ಸಾಧಕವನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಸೇವೆಯನ್ನು ಬರೆಯಲು ಸ್ನೇಹಿತರೊಬ್ಬರು ಸಲಹೆ ನೀಡಿದರು. ಇದನ್ನು ವಾದಿಸುವುದು ವೇಗವಾಗಿರುತ್ತದೆ, ಹೆಚ್ಚು ಉತ್ಪಾದಕವಾಗಿರುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ, ತಂಡದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂದು ನಮಗೆ ತಿಳಿದಿರುವುದರ ಬಗ್ಗೆ ತೀರ್ಪುಗಾರರು ಸಂತೋಷಪಡುತ್ತಾರೆ. ನಾನು C++ ನಲ್ಲಿ ಅಂತಹ ಕೆಲಸಗಳನ್ನು ಎಂದಿಗೂ ಮಾಡಿಲ್ಲ ಮತ್ತು ಉಳಿದ 20+ ಗಂಟೆಗಳನ್ನು ಸೂಕ್ತ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಹುಡುಕಲು, ಕಂಪೈಲ್ ಮಾಡಲು ಮತ್ತು ಲಿಂಕ್ ಮಾಡಲು ಸುಲಭವಾಗಿ ವಿನಿಯೋಗಿಸಬಹುದು ಎಂದು ನಾನು ಉತ್ತರಿಸಿದೆ. ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ನಾನು ಚಿಕನ್ ಔಟ್ ಮಾಡಿದ್ದೇನೆ. ಅದನ್ನೇ ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ ಮತ್ತು ಪೈಥಾನ್‌ನಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಶಾಂತವಾಗಿ ಪೂರ್ಣಗೊಳಿಸಿದ್ದೇವೆ.

ಈಗ, ಬಲವಂತದ ಸ್ವಯಂ-ಪ್ರತ್ಯೇಕತೆಯ ಸಮಯದಲ್ಲಿ, C++ ನಲ್ಲಿ ಸೇವೆಗಳನ್ನು ಹೇಗೆ ಬರೆಯುವುದು ಎಂದು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ನಾನು ನಿರ್ಧರಿಸಿದೆ. ಸೂಕ್ತವಾದ ಗ್ರಂಥಾಲಯವನ್ನು ನಿರ್ಧರಿಸುವುದು ಮೊದಲನೆಯದು. ನನ್ನ ಆಯ್ಕೆ ಬಿದ್ದುಹೋಯಿತು POCO, ಇದು ವಸ್ತು-ಆಧಾರಿತ ಶೈಲಿಯಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟಿರುವುದರಿಂದ ಮತ್ತು ಸಾಮಾನ್ಯ ದಾಖಲಾತಿಯನ್ನು ಸಹ ಹೆಮ್ಮೆಪಡುತ್ತದೆ. ಅಲ್ಲದೆ, ಅಸೆಂಬ್ಲಿ ವ್ಯವಸ್ಥೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಬಗ್ಗೆ ಪ್ರಶ್ನೆ ಉದ್ಭವಿಸಿದೆ. ಈ ಹಂತದವರೆಗೆ ನಾನು ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋ, IAR ಮತ್ತು ಬೇರ್ ಮೇಕ್‌ಫೈಲ್‌ಗಳೊಂದಿಗೆ ಮಾತ್ರ ಕೆಲಸ ಮಾಡಿದ್ದೇನೆ. ಮತ್ತು ಈ ಯಾವುದೇ ವ್ಯವಸ್ಥೆಗಳು ನನಗೆ ಇಷ್ಟವಾಗಲಿಲ್ಲ, ಏಕೆಂದರೆ ನಾನು ಸಂಪೂರ್ಣ ಸೇವೆಯನ್ನು ಡಾಕರ್ ಕಂಟೇನರ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಲು ಯೋಜಿಸಿದೆ. ನಂತರ ನಾನು cmake ಮತ್ತು ಆಸಕ್ತಿದಾಯಕ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಲು ನಿರ್ಧರಿಸಿದೆ ಕಾನನ್. ಈ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ನಿಮಗೆ ಎಲ್ಲಾ ಅವಲಂಬನೆಗಳನ್ನು ಒಂದೇ ಫೈಲ್‌ನಲ್ಲಿ ನೋಂದಾಯಿಸಲು ಅನುಮತಿಸಿದೆ

conanfile.txt
[ಅಗತ್ಯವಿದೆ]poco/1.9.3
libpq/11.5

[ಜನರೇಟರ್] ಸಿಮೇಕ್

ಮತ್ತು ಸರಳ ಆಜ್ಞೆಯೊಂದಿಗೆ "conan install ." ಅಗತ್ಯ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಸ್ಥಾಪಿಸಿ. ಸ್ವಾಭಾವಿಕವಾಗಿ, ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವುದು ಸಹ ಅಗತ್ಯವಾಗಿತ್ತು

CMakeLists.txt

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

ಅದರ ನಂತರ, ನಾನು PostgreSQL ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಲೈಬ್ರರಿಯನ್ನು ಹುಡುಕಲು ಪ್ರಾರಂಭಿಸಿದೆ, ಏಕೆಂದರೆ ಅದು ನನಗೆ ಸ್ವಲ್ಪ ಕೆಲಸ ಮಾಡಿದ ಅನುಭವವಾಗಿದೆ ಮತ್ತು ಇದು ನಮ್ಮ ಪೈಥಾನ್ ಸೇವೆಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಿತು. ಮತ್ತು ನಾನು ಏನು ಕಲಿತಿದ್ದೇನೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆಯೇ? ಇದು POCO ನಲ್ಲಿದೆ! ಆದರೆ ಕಾನನ್‌ಗೆ ಅದು POCO ದಲ್ಲಿದೆ ಎಂದು ತಿಳಿದಿಲ್ಲ ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂದು ತಿಳಿದಿಲ್ಲ; ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಹಳೆಯ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಇದೆ (ಈ ದೋಷದ ಬಗ್ಗೆ ನಾನು ಈಗಾಗಲೇ POCO ರಚನೆಕಾರರಿಗೆ ಬರೆದಿದ್ದೇನೆ). ಇದರರ್ಥ ನೀವು ಇನ್ನೊಂದು ಗ್ರಂಥಾಲಯವನ್ನು ಹುಡುಕಬೇಕಾಗಿದೆ.

ತದನಂತರ ನನ್ನ ಆಯ್ಕೆಯು ಕಡಿಮೆ ಜನಪ್ರಿಯ ಗ್ರಂಥಾಲಯದ ಮೇಲೆ ಬಿದ್ದಿತು ಲಿಬಿಪಿಜಿ. ಮತ್ತು ನಾನು ವಿಸ್ಮಯಕಾರಿಯಾಗಿ ಅದೃಷ್ಟಶಾಲಿಯಾಗಿದ್ದೆ, ಅದು ಈಗಾಗಲೇ ಕಾನನ್‌ನಲ್ಲಿತ್ತು ಮತ್ತು ಅದನ್ನು ಜೋಡಿಸಿ ಮತ್ತು ಜೋಡಿಸಲಾಗುತ್ತಿದೆ.

ವಿನಂತಿಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದಾದ ಸೇವಾ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಬರೆಯುವುದು ಮುಂದಿನ ಹಂತವಾಗಿದೆ.
ನಾವು 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 ಫೈಲ್ ಅನ್ನು ಸಹ ರಚಿಸಬೇಕು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ

.env

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

ನೀವು ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ನೋಡಬಹುದು ಗಿಥಬ್.

ಮತ್ತು ಈಗ ಡಾಕರ್‌ಫೈಲ್ ಮತ್ತು ಡಾಕರ್-ಕಂಪೋಸ್.ಐಎಂಎಲ್ ಬರೆಯುವ ಅಂತಿಮ ಹಂತ ಬಂದಿದೆ. ನಿಜ ಹೇಳಬೇಕೆಂದರೆ, ಇದು ಹೆಚ್ಚಿನ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಂಡಿತು, ಮತ್ತು ನಾನು ನೂಬ್ ಆಗಿರುವುದರಿಂದ ಮಾತ್ರವಲ್ಲ, ಪ್ರತಿ ಬಾರಿಯೂ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಮರುನಿರ್ಮಾಣ ಮಾಡುವುದು ಅಗತ್ಯವಾಗಿತ್ತು, ಆದರೆ ಕಾನನ್‌ನ ಮೋಸಗಳಿಂದಾಗಿ. ಉದಾಹರಣೆಗೆ, conan ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು, ಅಗತ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಮತ್ತು ನಿರ್ಮಿಸಲು, ಅದು “conan install .” ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಸಾಕಾಗುವುದಿಲ್ಲ, ಅದು -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