Aedificii caudices applicationes distributae. Primo adventu

In novissimis articulus Fundamenta theoricae architecturae reciprocae examinavimus. Tempus est loqui de fluit de notitia, vias ad efficiendum reactivum Erlang/Elixir systemata et exemplaria in illis nuntianda:

• Request-responsio
• Request-Chunked Responsio
• Responsio cum Request
• Publica-subscribe
• Inversa publicare-subscribe
• Negotium distribution

SOA, MSA et Nuntius

SOA, MSA sunt architecturae systematis quae regulas aedificandi ratiocinantes definiunt, dum primitiva ad eorum exsecutionem nuntius praebet.

Nolo architecturam hanc vel illam rationem promovere. Ego sum utens efficacissimis et utilibus exercitiis ad munus quoddam et negotium. Quicquid paradigma eligimus, melius est ut systema oculorum in unix-via caudices crearet: componentes cum minimo connectivo, singula entia responsabilia. API methodi actiones quam simplicissimas cum entibus praestant.

Nuntius est, ut nomen sonat, nuntius sectorem. Eius consectetur est suscipit et. Interfaces ad informationem mittendam, formatio canalium logicorum est tradendi informationes intra systema, fusura et conpensatio, necnon culpa in ambitu systematis tractans.
Nuntius nos evolvere non nititur certare vel reponere lepormq. Praecipua eius lineamenta:

• Distributio.
  Commutatio puncta in omnibus nodis racemis creari possunt, quam proxime in codice qui illis utitur.
• Simplicitas.
  Focus in boilerplate extenuando codicem et facilitatem usus.
• Melius perficientur.
  Non conamur functionem lepormq iterare, sed illustrare solum stratum architecturae et onerariae, quam in OTP quam maxime fieri potest, obscuratis sumptibus.
• Flexibilitate.
  Unaquaeque religio multarum permutationum exempla coniungi potest.
• Invicta consilio.
• Scalability.
  Nuntius crescit cum applicatione. Ut onus crescit, permutationem puncta singulis machinis movere potes.

Nota. Secundum norma normae meta-incepta bene apta sunt ad systemata complexum Erlang/Elixir. Omnes codice projecti in uno repositorio - umbella project. Eodem tempore, microserviae solitariae sunt maximeque simplices operationes quae entitatis separatae responsabiles sunt. Cum hoc accessu, facile est API totius systematis ponere, facile est mutationes facere, commodum est scribere unitatem et integrationem probationes.

Systema components directe vel per sectorem inter se occurrunt. Ex prospectu nuntiorum, unumquodque officium plures habet vitae gradus:

• Service initialization.
  In hoc statu processus et dependentiae ministerii exsequendi configurantur et inducuntur.
• Commutatio punctum creando.
  Ministerium stabili permutatione uti potest punctum in nodi configuratione determinatum, vel puncta commutationis dynamice creare.
• Servitii adnotationem.
  Ut petitiones inserviant, in puncto commutationis adscribi oportet.
• Normalis muneris.
  Ministerium utile opus producit.
• Perfectio operis.
  Sunt 2 genera shutdown possibiles: normales et subitis. Per normalem operationem, servitium a puncto commutationis disiungitur et desinit. In adiunctis subitis nuntius unum ex scriptis deficientibus exequitur.

Spectat satis perplexa, sed signum non est omne quod FORMIDULOSUS. Exempla codicis cum commentationibus in analysi exemplorum paulo post dabuntur.

Permutationes

Punctum commutationis est processus nuntius, qui logicam commercii cum componentibus intra messingem templates conficit. In omnibus exemplis infra positis, elementa inter se occurrunt per puncta permutationis, quarum compositio formae nuntius est.

Nuntius commutatione exemplaria (MEPs)

Globally, commutatio exemplaria in duos modos et unum modum dividi possunt. Illa responsionem nuntiorum advenientis implicant, haec non. A classic exemplum architecturae bipertitae exemplaris clientis-servatoris est exemplar postulatum responsionis. Intueamur exemplum eiusque modificationes.

Request-responsio seu RPC

RPC adhibetur cum responsionem ab alio processu accipere debemus. Hic processus potest eodem nodo currere vel in alio continente sito. Infra schema est de commercio inter clientem et servitorem per nuntios.

Cum nuntius omnino asynchronus est, pro client commutatio in 2 gradus dividitur;

1. petitionem misit

   messaging:request(Exchange, ResponseMatchingTag, RequestDefinition, HandlerProcess).

   Exchange Unicum nomen commutationis punctum
   ResponseMatchingTag ‒ pittacium localem responsionem dispensando. Exempli gratia, in casu mittendo plures petitiones identicas ad diversos utentes pertinentes.
   RequestDefinition - petitio corporis
   HandlerProcess ‒ tracto PID. Hic processus responsionem a servo accipiet.

2. Processus responsionis

   handle_info(#'$msg'{exchange = EXCHANGE, tag = ResponseMatchingTag,message = ResponsePayload}, State)

   ResponsePayload — responsum servo.

Pro servo, processus etiam in 2 gradibus consistit;

1. Initializing in commutatione punctus
2. Processus petitionum receptarum

Exemplum hanc cum codice illustremus. Dicamus nos opus esse servitutem simplicem efficiendam, quae unicum tempus exactum praebet modum.

Servo codice

Definiamus servitium API in api.hrl;

%% =====================================================
%%  entities
%% =====================================================
-record(time, {
  unixtime :: non_neg_integer(),
  datetime :: binary()
}).

-record(time_error, {
  code :: non_neg_integer(),
  error :: term()
}).

%% =====================================================
%%  methods
%% =====================================================
-record(time_req, {
  opts :: term()
}).
-record(time_resp, {
  result :: #time{} | #time_error{}
}).

Diffiniamus servitium moderatoris in time_controller.erl

%% В примере показан только значимый код. Вставив его в шаблон gen_server можно получить рабочий сервис.

%% инициализация gen_server
init(Args) ->
  %% подключение к точке обмена
  messaging:monitor_exchange(req_resp, ?EXCHANGE, default, self())
  {ok, #{}}.

%% обработка события потери связи с точкой обмена. Это же событие приходит, если точка обмена еще не запустилась.
handle_info(#exchange_die{exchange = ?EXCHANGE}, State) ->
  erlang:send(self(), monitor_exchange),
  {noreply, State};

%% обработка API
handle_info(#time_req{opts = _Opts}, State) ->
  messaging:response_once(Client, #time_resp{
result = #time{ unixtime = time_utils:unixtime(now()), datetime = time_utils:iso8601_fmt(now())}
  });
  {noreply, State};

%% завершение работы gen_server
terminate(_Reason, _State) ->
  messaging:demonitor_exchange(req_resp, ?EXCHANGE, default, self()),
  ok.

codice client

Ut petitionem ad officium mittat, petitionem nuntii API usquam in cliente tuo vocare potes.

case messaging:request(?EXCHANGE, tag, #time_req{opts = #{}}, self()) of
    ok -> ok;
    _ -> %% repeat or fail logic
end

In systemate distributo, conformatio partium multum differre potest et in tempore petitionis, nuntius nondum committitur, vel ministerium moderatoris non paratus erit ad petitionem serviendi. Ergo necesse est nuntium nuntium reprimere et casum defectum tractare.
Post prospere misso, cliens responsionem vel errorem e servitio recipiet.
Utrumque tractamus in handle_info:

handle_info(#'$msg'{exchange = ?EXCHANGE, tag = tag, message = #time_resp{result = #time{unixtime = Utime}}}, State) ->
  ?debugVal(Utime),
  {noreply, State};

handle_info(#'$msg'{exchange = ?EXCHANGE, tag = tag, message = #time_resp{result = #time_error{code = ErrorCode}}}, State) ->
  ?debugVal({error, ErrorCode}),
  {noreply, State};

Request-Chunked Responsio

Praestat mittere nuntios ingentes vitare. In hac alacritate ac stabili operatione totius systematis dependet. Si responsio interrogationi multam memoriam sumpsit, ea in partes scindendi facienda est.

Exempla duo talium casuum tibi concedam;

• Composita notitia binaria commutant, ut fasciculi. Responsio solvens in partes minutas adiuvat te efficaciter operari cum scriniis cuiuslibet magnitudinis et memoria evitandi redundat.
• Elenchus. Exempli gratia, necesse est omnes monumenta ex ingenti mensa in datorum eligere et eas ad alia componentia transferre.

Haec responsiones motivum secundum locum voco. Ceterum, 1024 nuntii 1 MB meliores sunt quam unum nuntium 1 GB.

In botro Erlang, additamentum addimus beneficium - reducendo onere in punctum commutationis et retis, cum responsa statim mittuntur recipienti, punctum commutationis praetermittens.

Responsio cum Request

Haec est rarissima modificatio RPC exemplaris ad aedificandum systemata alternis.

Publica-subscribe (distributio ligno)

Systema eventi agitatae eas usores quam primum data est parata tradent. Ita systemata proniora sunt ad exemplar impulsum quam ad exemplar viverra vel capitationis. Haec factura permittit ut opes perdas adsidue petendo et exspectando datas.
Figura ostendit processum distribuendi nuntium consumerent in certo argumento subscriptum.

Classica exempla utendi exemplaris sunt distributio civitatis: lusus mundi in ludis computatris, mercatus notitia in commutationibus, utilis notitia in notitia pascitur.

Intueamur subscribens codice:

init(_Args) ->
  %% подписываемся на обменник, ключ = key
  messaging:subscribe(?SUBSCRIPTION, key, tag, self()),
  {ok, #{}}.

handle_info(#exchange_die{exchange = ?SUBSCRIPTION}, State) ->
  %% если точка обмена недоступна, то пытаемся переподключиться
  messaging:subscribe(?SUBSCRIPTION, key, tag, self()),
  {noreply, State};

%% обрабатываем пришедшие сообщения
handle_info(#'$msg'{exchange = ?SUBSCRIPTION, message = Msg}, State) ->
  ?debugVal(Msg),
  {noreply, State};

%% при остановке потребителя - отключаемся от точки обмена
terminate(_Reason, _State) ->
  messaging:unsubscribe(?SUBSCRIPTION, key, tag, self()),
  ok.

Fons munus vocare potest nuntium in quovis loco convenienti divulgandi;

messaging:publish_message(Exchange, Key, Message).

Exchange — nomen commutationis punctum;
Key - profectus clavis
Nuntius - payload

Inversa publicare-subscribe

Dilatando pub-sub, formam logging convenientem licebit. Fontes et perussi omnino diversa esse possunt. Figura demonstrat causam uno consumere et multiplicibus fontibus.

Distributio negotium exemplaris

Fere omne consilium involvit negotium processus differendum, sicut relationes generans, notificationes tradens et notitias ex systematibus tertii partium recuperandis. Perputatio systematis in his muneribus faciendis facile pertractandis addendo transcendere potest. Reliquum nobis est, ut processus gregarium formet et officia inter se aequaliter distribuat.

Inspice condiciones quae nascuntur utentes exemplo 3 tracto. Etiam in stadio distribuendi munus, quaestio aequitatis distributionis ac redundantia tractorum oritur. Distributio rotunda Robini responsabilis erit aequitatis, et, ut evitent condicionem redundantiae tracto, restrictionem inducemus. prefetch_limit. In conditionibus caducis prefetch_limit ne unum tracto ab omnibus operibus.

Nuntius administrat queues et prioritatem dispensando. Processus officia accipiunt prout venerint. Negotium perficiet feliciter vel deficiet;

• messaging:ack(Tack) - dicitur si nuntium feliciter processit
• messaging:nack(Tack) — vocavi in ​​omnibus condicionibus. Cum negotium redditur, nuntius ad alium tracto praeteribit.

Ponatur incomplexum defectum in tribus operibus dispensando factum: processus 1, post susceptum negotium, increpuit sine tempore, ut aliquid referret ad punctum commutationis. In hoc casu, punctum commutationis negotium ad alium tracto transferet postquam ack timeout expiravit. Horum autem causa tracto 3 negotium omisit et nackum misit: quo facto negotium etiam ad alium tractum translatum est, qui id feliciter perfecit.

Primae summary

Fundamenta structurae rationum distributarum intexuimus et praecipuam eorum usum in Erlang/Elixir intelleximus.

Coniungendo formas fundamentales, paradigmata complexa aedificare potes ad solvendas emergentes quaestiones.

In ultima seriei parte videbimus quaestiones generales ordinandi officia, fugata et conpensationes, et etiam loqui de practica parte scalabilitatis et culpae tolerantiae systematum.

Finis secundae partis.

photo Marius Christensen
Illustrationes paratae utens websequencediagrams.com

Source: www.habr.com