Microservices in C++. Ficta an veritas?

In hoc articulo loquar quomodo a template (cookiecutter) creavi et ambitum constituo scribendo CETERA API servitium in C++ utendo docker/composito et conan involucrum villicum.

Proximo hackathon, in quo e elit backend participavi, quaesitum est de quo microservio proximo scribendo uteretur. Omnia, quae scripta sunt, huc usque scripta sunt comes in Pythone, quia collega meus in hoc campo peritissimus erat et in munere elaboravit backends, cum essem fere elit systems infixa et in magna et horribili C ++ scripsi, et modo didici Pythonem in universitate.

Ita eramus in scribendo officio praecipuo onere servitii, cuius praecipuum opus erat praecurrere notitias ad ipsum venientes et scribendarum datorum. Et post alium fumum confractum, amicus suggessit me, ut C++ elit, hoc opusculum scribere utens pros. Hoc argumento est quod velocior, uberior, et generatim, iudices gaudebit quomodo scimus quomodo facultates bigas administrare cognoscimus. Ad quod respondi me talia nunquam fecisse in C++, ac facile reliquas XX+ horas ad investigandas, componendas et connexiones aptas bibliothecas insumere possem. Plane, ego pulled. Id quod statuimus et placide omnia in Pythone perfecerunt.

Nunc, per seiunctionem coactus, officia in C++ scribere decrevi. Primum faciendum erat de bibliotheca idonea. Meum arbitrium cecidit in POCOcum scriptum esset in re ordinanda stilo et etiam in communi documento gloriari. Item quaestio orta est de electione conventus ratio. Huc usque cum Visual Studio tantum laboravi, IAR facundia nudavi. Et nemo harum systematum me appellabat, cum totam operam in vase phialam currere cogitabam. Tunc placuit experior ut instar de cmake et interesting sarcina procurator conan. Hoc sarcina procurator permisit tibi omnes clientelas in uno fasciculo subcriptio

conanfile.txt
poco/1.9.3
libpq/11.5

[generatores] cmake

et simplici mandato "conan install." necessarias bibliothecas instituere. Naturaliter etiam necesse fuit mutationes facere

CMakeLists.txt

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

After that, I started looking for a library to work with PostgreSQL, since it was the one I had little experience working with, and it was also the one our Python services interacted with. Et scin' quid didici? Est in POCO! Sed Conanus nescit eam in POCO esse et eam aedificare nescit, in promptuario est iam in repositorio (de hoc errore scriptoribus POCO scriptum est). Hoc modo aliam bibliothecam quaerere debebis.

Et tunc electio mea cecidit in bibliothecam popularem minus libpg. Et incredibile fui felix, iam in conan erat et etiam convenerunt et congregabantur.

Proximus gradus erat ut scriberet munus template quod potest processum petitiones.
Classem nostram TemplateServerApp ex Poco ::Util ::ServerApplicationem hereditandam debemus et methodum principalem subiciamus.

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;
}

Praecipua methodo parametros ponendus est: portum, numerum staminum et magnitudinem queue. Ac potissimum, tracto notandum est postulationibus advenientis. Fit creando officinam

TemplateRequestHandlerFactory

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

In casu meo, simpliciter idem tracto omni tempore creat - TemplateServerAppHandler. Hoc est in quo negotio logicae nostrae ponere possumus.

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();
    }
};

Templum quoque creavi cum PostgreSQL genus operis. Ad simplicem SQL faciendam, ut mensam condens, modus est ExecuteSQL (). Plures interrogationes implicatae vel notae retrievales, nexum obtinendum habebis per GetConnection () uti & api libpg. (Fortasse post hanc iniustitiam corrigam).

Database

#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;
};

Omnes parametri ad connexionem cum database ex ambitu sumuntur, sic etiam debes fasciculi .env creare et configurare

.env

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

Potes videre omnia in codice github.

Nunc postremum e scribendi stadio strumentum et docker-compose.yml. Quod honestum esse, id maxime temporis sumpsit, non solum quia noob sum, quia omni tempore bibliothecas reficere oportuit, sed propter casus Conani. Exempli gratia, ad conan ut extrahere, instituere et aedificare necessarias clientelas, non sufficit ut "conan install .", praeterea opus est compiler.libcxx=libstdc ++ 11 parametri transire, secus tu periculum paras fasciculum errorum in applicatione tua conjunctionis ad scaenam tuam. Hoc errore aliquot horis adhaesi sum et spero hunc articulum adiuvabit alios homines breviore tempore hanc quaestionem solvere.

Deinde, cum scriberem docker-compose.yml, de consilio amici mei addidi subsidium crustulum et nunc valeas te plenae exempli causa declinare API officium in C++, cum ambitu amet, et postgreSQL inauguratum, solum intrando "crustulum" in consolatorium. https://github.com/KovalevVasiliy/cpp_rest_api_template.git" Et tunc "docker-construe sursum —aedificare".

Spero hanc formulam incipientes adiuvabunt in difficili via elaborandi REST API applicationes in magnis et validis, sed tam incondite lingua sicut C++.
Etiam, hic valde suadeo legendi haec articulus. Fusius explicat quomodo cum POCO laborare et ALIQUID API ministerium tuum scribere.

Source: www.habr.com

Microservices in C++. Ficta an veritas?

Add a comment Отменить ответ