ZeroMQ | ZeroMQ for Swift - ZeroMQ is a 0mq binding for Swift | Networking library

Q1 :
"Is it possible to connect to a ZeroMQ-Publisher-Socket WITHOUT implementing or depending on the C++ compiled file of ZeroMQ?"

A1 :
Yes, it is. It is quite enough to re-implement the published ZeroMQ ZMTP RFC-s relevant for the use-case & your code is granted to become interoperable, irrespective of the implementation language / deployment ecosystem, if it meets all the ZMTP RFC-s' mandatory requirements. So it is doable.

Q2 :
"... ZeroMQ uses it's own protocoll (please verify)."

A2 :
No, in the sense of OSI-ISO-L2/L3 stack.
Yes, in the sense of higher layer application-driven protocols, where the ZMTP RFC-s apply for the most of the ZeroMQ Scalable Formal Communication Patterns' Archetypes ( may read more on ZeroMQ sockets are not sockets as you know them ), yet there are also tools to interface with O/S plain-sockets' fd-s, where needed. Still A1 applies here.

Q3 :
"Can I subscribe to a ZeroMQ-Publisher-Socket with ...? If yes, how?"

A3 :
Yes, it possible when your code follows the published ZMTP RFC-s. Implement all ZMTP RFC-s' mandatory properties & you are granted an interoperability with any other, ZeroMQ-ZMTP-RFC-s' compliant, node.

Q4 :
"Are there alternatives?"

A4 :
Yes, if your design can extend the Server-side, adding another AccessPoint-s there, using ZMQ_STREAM Scalable Formal Communication Archetype there, may reduce your Flutter-side scope of ZMTP RFC-s needed, as interfacing to native plain-socket will be the only one to handle and the "functionality gap" thereof can be handled on the Server-side of the link ( easily handling all the subscription management & message filtering, that must meet the ZeroMQ ZMTP RFC-s, so why not tandem it inside the Server-side before connecting the down-stream to Flutter App - smart, isn't it? )

It seems to me that the first problem is with the order of these lines:

Let me share a view on how ZeroMQ could meet the above defined Intention.

Let's rather use ZeroMQ Scalable Formal Communication Pattern Archetypes ( as they are RTO now, not as we may wish them to be at some, yet unsure, point in (a just potentially happening) future evolution state ).

We need not hesitate to use many more ZeroMQ-based connections among a herd of coming/leaving client-instance(s) and the server

For example :

Client .connect()-s a REQ-socket to Server-address:port-A to ask for a "job"-ticket processing over this connection

Client .connect()-s a SUB-socket to Server-address:port-B to listen ( if present ) about published announcements about already completed "job"-tickets that are Server-ready to deliver results for

Client exposes another REQ-socket to request upon an already broadcast "job"-ticket completion announcement message, it has just heard about over the SUB-socket, to get "job"-ticket results finally delivered, if proving itself, by providing a proper / matching job-ticket-AUTH-key to proof its right to receive the publicly announced results' availability, using this same socket to deliver a POSACK-message to Server upon client has correctly received this "job"-ticket results "in hands"

Server exposes REP-socket to respond each client ad-hoc upon a "job"-ticket request, notifying this way about having "accepted"-job-ticket, delivering also a job-ticket-AUTH-key for later pickup of results

Server exposes PUB-socket to announce any and all not yet picked-up "finished"-job-tickets

Server exposes another REP-socket to receive any possible attempt to request to deliver "job"-ticket-results. Upon verifying there delivered job-ticket-AUTH-key, Server decides whether the respective REQ-message had matching job-ticket-AUTH-key to indeed deliver a proper message with results, or whether a match did not happen, in which case a message will carry some other payload data ( logic is left for further thoughts, so as to prevent potential bruteforcing or eavesdropping and similar, less primitive attacks on stealing the results )

Clients need not stay waiting for results live/online and/or can survive certain amounts of LoS, L2/L3-errors or network-storm stresses

Clients need just to keep some kind of job-ticket-ID and job-ticket-AUTH-key for later retrieving of the Server-processes/maintained/auth-ed results

Server will keep listening for new jobs

Server will accept new job-tickets with providing a privately added job-ticket-AUTH-key

Server will process job-tickets as it will to do so

Server will maintain a circular-buffer of completed job-tickets to be announced

Server will announce, in due time and repeated as decided in public, job-tickets, that are ready for client-initiated retrieval

Server will accept new retrieval requests

Server will verify client-requests for matching any announced job-ticket-ID and testing if job-ticket-AUTH-key match either

Server will respond to either matching / non-matching job-ticket-ID results retrieval request(s)

Server will remove a job-ticket-ID from a circular-buffer only upon both POSACK-ed AUTH-match before a retrieval and a POSACK-message re-confirmed delivery to client

Consider creating a separate environment, e.g.,

Q : _{What is the expected behaviour after setting these socket options ?}

A :
well,
there are two-fold effect of the said settings. One, that actually works for your setup goals ( i.e. going & sending (most probably ZMTP/3.1) ZMTP_PING connection-oriented service-sublayer "ZMTP/3.1-service-packets" and reciprocally, not sure, but most often, adequately formed "ZMTP/{3.1|2.x|1.0}-service-packets" (hopefully delivered) back. These "service-packets" are visible on the wire-line (if present - an inproc://-transport-class and vmci://-transport-class too have no actual wire a typical user can hook-on and sniff-traffic in, but some kind of pointer-acrobatics used for RAM-mapping), so a protocol-analyser will "see" them id decodes like this:

Build tags in you environment.yml are quite strict requirements to satisfy and most often not needed. In your case, changing the yml file to

After mocking by jest.mock(), when the .wsClient() and .zmqSock() methods are called in the app.js file and app.spec.js file, the sock and ws objects in app.js are different with the app.spec.js.

You are installing some statically compiled dependencies in your Docker environment, like libc-dev, geos-dev, and geos. You have to also include those static dependencies in the Lambda deployment zip file. Also, to include statically compiled dependencies for use in AWS Lambda you have to use the same operating system Lambda uses, which is Amazon Linux, not Alpine Linux.

Luckily there are two alternatives now that make this much easier:

Lambda Layers

Lambda Layers are Lambda dependencies that can be packaged up in a reusable method, that can also be shared with other developers. In this case someone has already created a shapely Lambda Layer (and someone else here) that you can simply include in your Lambda function instead of trying to package it yourself.

If you still want to build it yourself you could look at that project's source code to see how they are building the layer.

Lambda Containers

Instead of creating a zip deployment, you could create a Docker image and deploy it to Lambda. You do have to implement a specific interface inside your Lambda container if you go this route, and it is easiest to do this by starting with one of the official AWS Lambda base images.

After a lot of research, I stumbled on to Mamba doesn't find a solution when mixing conda forge defaults and not specifying Python explicitly 1102. So I just edited nbdev.yml from