C++ ਵਿੱਚ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼। ਕਲਪਨਾ ਜਾਂ ਅਸਲੀਅਤ?

ਇਸ ਲੇਖ ਵਿੱਚ ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ ਕਿ ਮੈਂ ਇੱਕ ਟੈਂਪਲੇਟ (ਕੂਕੀਕਟਰ) ਕਿਵੇਂ ਬਣਾਇਆ ਅਤੇ ਡੌਕਰ/ਡੌਕਰ-ਕੰਪੋਜ਼ ਅਤੇ ਕੌਨਨ ਪੈਕੇਜ ਮੈਨੇਜਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ C++ ਵਿੱਚ ਇੱਕ REST API ਸੇਵਾ ਲਿਖਣ ਲਈ ਇੱਕ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕੀਤਾ।

ਅਗਲੇ ਹੈਕਾਥਨ ਦੇ ਦੌਰਾਨ, ਜਿਸ ਵਿੱਚ ਮੈਂ ਇੱਕ ਬੈਕਐਂਡ ਡਿਵੈਲਪਰ ਵਜੋਂ ਹਿੱਸਾ ਲਿਆ ਸੀ, ਇਹ ਸਵਾਲ ਉੱਠਿਆ ਕਿ ਅਗਲੀ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਨੂੰ ਲਿਖਣ ਲਈ ਕੀ ਵਰਤਣਾ ਹੈ। ਹੁਣ ਤੱਕ ਜੋ ਵੀ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਉਹ ਸਭ ਕੁਝ ਮੇਰੇ ਅਤੇ ਮੇਰੇ ਦੁਆਰਾ ਲਿਖਿਆ ਗਿਆ ਸੀ ਕਾਮਰੇਡ ਪਾਈਥਨ ਵਿੱਚ, ਕਿਉਂਕਿ ਮੇਰਾ ਸਹਿਕਰਮੀ ਇਸ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਮਾਹਰ ਸੀ ਅਤੇ ਪੇਸ਼ੇਵਰ ਤੌਰ 'ਤੇ ਬੈਕਐਂਡ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਦੋਂ ਕਿ ਮੈਂ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਏਮਬੇਡਡ ਸਿਸਟਮ ਡਿਵੈਲਪਰ ਸੀ ਅਤੇ ਮਹਾਨ ਅਤੇ ਭਿਆਨਕ C++ ਵਿੱਚ ਲਿਖਿਆ ਸੀ, ਅਤੇ ਮੈਂ ਹੁਣੇ ਯੂਨੀਵਰਸਿਟੀ ਵਿੱਚ ਪਾਈਥਨ ਸਿੱਖਿਆ ਹੈ।

ਇਸ ਲਈ, ਸਾਨੂੰ ਇੱਕ ਉੱਚ-ਲੋਡ ਸੇਵਾ ਲਿਖਣ ਦੇ ਕੰਮ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ, ਜਿਸਦਾ ਮੁੱਖ ਕੰਮ ਇਸ ਵਿੱਚ ਆਉਣ ਵਾਲੇ ਡੇਟਾ ਨੂੰ ਪ੍ਰੀਪ੍ਰੋਸੈਸ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਲਿਖਣਾ ਸੀ। ਅਤੇ ਇੱਕ ਹੋਰ ਸਮੋਕ ਬ੍ਰੇਕ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਦੋਸਤ ਨੇ ਸੁਝਾਅ ਦਿੱਤਾ ਕਿ ਮੈਂ, ਇੱਕ C++ ਡਿਵੈਲਪਰ ਵਜੋਂ, ਇਸ ਸੇਵਾ ਨੂੰ ਪੇਸ਼ਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਿਖਾਂ। ਇਸ ਦੀ ਦਲੀਲ ਇਹ ਹੈ ਕਿ ਇਹ ਤੇਜ਼, ਵਧੇਰੇ ਲਾਭਕਾਰੀ, ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ, ਜਿਊਰੀ ਇਸ ਗੱਲ ਤੋਂ ਖੁਸ਼ ਹੋਵੇਗੀ ਕਿ ਅਸੀਂ ਟੀਮ ਦੇ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਿਵੇਂ ਕਰਨਾ ਜਾਣਦੇ ਹਾਂ। ਜਿਸ ਦਾ ਮੈਂ ਜਵਾਬ ਦਿੱਤਾ ਕਿ ਮੈਂ C++ ਵਿੱਚ ਅਜਿਹਾ ਕੰਮ ਕਦੇ ਨਹੀਂ ਕੀਤਾ ਸੀ ਅਤੇ ਬਾਕੀ ਬਚੇ 20+ ਘੰਟੇ ਆਸਾਨੀ ਨਾਲ ਢੁਕਵੀਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਖੋਜਣ, ਕੰਪਾਇਲ ਕਰਨ ਅਤੇ ਲਿੰਕ ਕਰਨ ਲਈ ਲਗਾ ਸਕਦਾ ਸੀ। ਬਸ ਪਾਓ, ਮੈਨੂੰ ਬਾਹਰ chickened. ਇਹ ਉਹ ਹੈ ਜਿਸ 'ਤੇ ਅਸੀਂ ਫੈਸਲਾ ਕੀਤਾ ਅਤੇ ਪਾਈਥਨ ਵਿੱਚ ਸਭ ਕੁਝ ਸ਼ਾਂਤੀ ਨਾਲ ਪੂਰਾ ਕੀਤਾ।

ਹੁਣ, ਜ਼ਬਰਦਸਤੀ ਸਵੈ-ਅਲੱਗ-ਥਲੱਗ ਹੋਣ ਦੇ ਦੌਰਾਨ, ਮੈਂ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ ਕਿ C++ ਵਿੱਚ ਸੇਵਾਵਾਂ ਕਿਵੇਂ ਲਿਖਣੀਆਂ ਹਨ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਢੁਕਵੀਂ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਫੈਸਲਾ ਕਰਨਾ ਸੀ। ਮੇਰੀ ਪਸੰਦ 'ਤੇ ਡਿੱਗ ਗਿਆ POCO, ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਵਸਤੂ-ਅਧਾਰਿਤ ਸ਼ੈਲੀ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਸੀ ਅਤੇ ਆਮ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਵੀ ਸ਼ੇਖੀ ਮਾਰਦਾ ਹੈ। ਨਾਲ ਹੀ, ਅਸੈਂਬਲੀ ਪ੍ਰਣਾਲੀ ਦੀ ਚੋਣ ਕਰਨ ਬਾਰੇ ਵੀ ਸਵਾਲ ਉੱਠਿਆ। ਇਸ ਬਿੰਦੂ ਤੱਕ ਮੈਂ ਸਿਰਫ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ, ਆਈਏਆਰ ਅਤੇ ਬੇਅਰ ਮੇਕਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕੀਤਾ ਹੈ। ਅਤੇ ਇਹਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਸਿਸਟਮ ਨੇ ਮੈਨੂੰ ਅਪੀਲ ਨਹੀਂ ਕੀਤੀ, ਕਿਉਂਕਿ ਮੈਂ ਪੂਰੀ ਸੇਵਾ ਨੂੰ ਡੌਕਰ ਕੰਟੇਨਰ ਵਿੱਚ ਚਲਾਉਣ ਦੀ ਯੋਜਨਾ ਬਣਾਈ ਸੀ। ਫਿਰ ਮੈਂ 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 ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਭਾਲ ਸ਼ੁਰੂ ਕੀਤੀ, ਕਿਉਂਕਿ ਇਹ ਉਹ ਸੀ ਜਿਸ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਮੈਨੂੰ ਬਹੁਤ ਘੱਟ ਅਨੁਭਵ ਸੀ, ਅਤੇ ਇਹ ਉਹੀ ਸੀ ਜਿਸ ਨਾਲ ਸਾਡੀ ਪਾਈਥਨ ਸੇਵਾਵਾਂ ਨੇ ਗੱਲਬਾਤ ਕੀਤੀ ਸੀ। ਅਤੇ ਕੀ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਮੈਂ ਕੀ ਸਿੱਖਿਆ ਹੈ? ਇਹ POCO ਵਿੱਚ ਹੈ! ਪਰ ਕੋਨਨ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਇਹ POCO ਵਿੱਚ ਹੈ ਅਤੇ ਇਹ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਇਸਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ; ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਇੱਕ ਪੁਰਾਣੀ ਸੰਰਚਨਾ ਫਾਈਲ ਹੈ (ਮੈਂ ਪਹਿਲਾਂ ਹੀ POCO ਦੇ ਨਿਰਮਾਤਾਵਾਂ ਨੂੰ ਇਸ ਗਲਤੀ ਬਾਰੇ ਲਿਖਿਆ ਹੈ)। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕਿਸੇ ਹੋਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਭਾਲ ਕਰਨੀ ਪਵੇਗੀ।

ਅਤੇ ਫਿਰ ਮੇਰੀ ਪਸੰਦ ਇੱਕ ਘੱਟ ਪ੍ਰਸਿੱਧ ਲਾਇਬ੍ਰੇਰੀ 'ਤੇ ਡਿੱਗ ਗਈ libpg. ਅਤੇ ਮੈਂ ਅਵਿਸ਼ਵਾਸ਼ਯੋਗ ਤੌਰ 'ਤੇ ਖੁਸ਼ਕਿਸਮਤ ਸੀ, ਇਹ ਪਹਿਲਾਂ ਹੀ ਕੋਨਨ ਵਿੱਚ ਸੀ ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਇਕੱਠਾ ਅਤੇ ਇਕੱਠਾ ਕੀਤਾ ਜਾ ਰਿਹਾ ਸੀ.

ਅਗਲਾ ਕਦਮ ਇੱਕ ਸੇਵਾ ਟੈਂਪਲੇਟ ਲਿਖਣਾ ਸੀ ਜੋ ਬੇਨਤੀਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦਾ ਹੈ।
ਸਾਨੂੰ 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(). ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਪੁੱਛਗਿੱਛਾਂ ਜਾਂ ਡਾਟਾ ਪ੍ਰਾਪਤੀ ਲਈ, ਤੁਹਾਨੂੰ ਇਸ ਰਾਹੀਂ ਇੱਕ ਕਨੈਕਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੋਵੇਗਾ ਕਨੈਕਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰੋ() ਅਤੇ 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

'ਤੇ ਤੁਸੀਂ ਸਾਰਾ ਕੋਡ ਦੇਖ ਸਕਦੇ ਹੋ github.

ਅਤੇ ਹੁਣ dockerfile ਅਤੇ docker-compose.yml ਲਿਖਣ ਦਾ ਅੰਤਮ ਪੜਾਅ ਆਉਂਦਾ ਹੈ। ਇਮਾਨਦਾਰ ਹੋਣ ਲਈ, ਇਸ ਵਿੱਚ ਜ਼ਿਆਦਾਤਰ ਸਮਾਂ ਲੱਗਿਆ, ਅਤੇ ਨਾ ਸਿਰਫ ਇਸ ਲਈ ਕਿ ਮੈਂ ਇੱਕ ਨੌਬ ਹਾਂ, ਕਿਉਂਕਿ ਹਰ ਵਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਣਾ ਜ਼ਰੂਰੀ ਸੀ, ਪਰ ਕੌਨਨ ਦੀਆਂ ਕਮੀਆਂ ਕਾਰਨ. ਉਦਾਹਰਨ ਲਈ, ਕੋਨਨ ਨੂੰ ਲੋੜੀਂਦੀ ਨਿਰਭਰਤਾ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ, ਸਥਾਪਤ ਕਰਨ ਅਤੇ ਬਣਾਉਣ ਲਈ, "conan install" ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇਹ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ, ਇਸ ਨੂੰ -s compiler.libcxx=libstdc++11 ਪੈਰਾਮੀਟਰ ਪਾਸ ਕਰਨ ਦੀ ਵੀ ਲੋੜ ਹੈ, ਨਹੀਂ ਤਾਂ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਲਿੰਕ ਕਰਨ ਦੇ ਪੜਾਅ 'ਤੇ ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੀਆਂ ਗਲਤੀਆਂ ਹੋਣ ਦਾ ਖ਼ਤਰਾ ਹੈ। ਮੈਂ ਕਈ ਘੰਟਿਆਂ ਤੋਂ ਇਸ ਗਲਤੀ ਨਾਲ ਫਸਿਆ ਹੋਇਆ ਹਾਂ ਅਤੇ ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਲੇਖ ਘੱਟ ਸਮੇਂ ਵਿੱਚ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਵਿੱਚ ਹੋਰ ਲੋਕਾਂ ਦੀ ਮਦਦ ਕਰੇਗਾ।

ਅੱਗੇ, docker-compose.yml ਲਿਖਣ ਤੋਂ ਬਾਅਦ, ਮੇਰੇ ਦੋਸਤ ਦੀ ਸਲਾਹ 'ਤੇ, ਮੈਂ ਸਮਰਥਨ ਜੋੜਿਆ ਕੁਕੀਕਟਰ ਅਤੇ ਹੁਣ ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਨੂੰ C++ ਵਿੱਚ ਇੱਕ REST API ਸੇਵਾ ਲਈ ਇੱਕ ਸੰਪੂਰਨ ਟੈਮਪਲੇਟ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ, ਇੱਕ ਅਨੁਕੂਲਿਤ ਵਾਤਾਵਰਣ ਦੇ ਨਾਲ, ਅਤੇ PostgreSQL ਸਥਾਪਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਬਸ ਕੰਸੋਲ ਵਿੱਚ "ਕੂਕੀਕਟਰ" ਦਾਖਲ ਕਰਕੇ https://github.com/KovalevVasiliy/cpp_rest_api_template.git" ਅਤੇ ਫਿਰ “ਡੌਕਰ-ਕੰਪੋਜ਼ ਅੱਪ —ਬਿਲਡ”।

ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਟੈਮਪਲੇਟ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਨੂੰ ਮਹਾਨ ਅਤੇ ਸ਼ਕਤੀਸ਼ਾਲੀ, ਪਰ C++ ਵਰਗੀ ਬੇਢੰਗੀ ਭਾਸ਼ਾ ਵਿੱਚ REST API ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਦੇ ਉਨ੍ਹਾਂ ਦੇ ਔਖੇ ਮਾਰਗ 'ਤੇ ਮਦਦ ਕਰੇਗਾ।
ਨਾਲ ਹੀ, ਮੈਂ ਇੱਥੇ ਪੜ੍ਹਨ ਦੀ ਜ਼ੋਰਦਾਰ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ ਇਹ ਲੇਖ। ਇਹ ਵਧੇਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਦੱਸਦਾ ਹੈ ਕਿ POCO ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ ਅਤੇ ਆਪਣੀ ਖੁਦ ਦੀ REST API ਸੇਵਾ ਕਿਵੇਂ ਲਿਖਣੀ ਹੈ।

ਸਰੋਤ: www.habr.com