etcd VS nsq

Apache APISIX is an API Gateway. By default, it stores its configuration in etcd, a distributed key-value store - the same one used by Kubernetes. Note that in real-world scenarios, we should set up etcd clustering to improve the resiliency of the solution. For this post, we will limit ourselves to a single etcd instance. Apache APISIX offers an admin API via HTTP endpoints. Finally, the gateway forwards calls from the client to an upstream. Here's an overview of the architecture and the required certificates:

While exploring popular projects such as etcd and especially traefik, I noticed a violation of the principle that states "interfaces should belong to the package that uses values of the interface type, not the package that implements those values." For example, Here we can see that ManagerFactory import Registry interface that placed here and implementations of this interface in the same package, which violates the aforementioned principle. Even if the interface is simply a specification, it should still be defined on the consumer side. Is it considered bad practice to follow what traefik does in this case or I doesn't understand somthing? P.S. I'm newcomer, so sorry if it's silly question.

In case of data sensitivity, you can enable the encrypted communication function of etcd for encrypted data transmission. Refer to the sample script provided by the etcd project.

Step 0: You have a strong grasp on who uses the tool/product/service and for what purpose. That can take weeks, months, or years depending on the specific project you're contributing to. A little NodeJS module? Probably closer to days. etcd? Probably closer to months/years.

etcd is not secure - etcd is where Kubernetes secrets are stored. Though etcd is a distributed key/value store with great performance, it lacks key features when it comes to handling sensitive data such as audit log, key rotation, and encryption of key.

You know how Kubernetes is absolutely blowing up? Well there's one piece of technology that it all depends on -- etcd.

FROM quay.io/coreos/etcd:v3.5.0 as etcd FROM alpine:3.17 RUN apk add --no-cache tar # Taken from https://github.com/etcd-io/etcd/blob/main/Dockerfile-release.amd64 COPY --from=etcd /usr/local/bin/etcd /usr/local/bin/ COPY --from=etcd /usr/local/bin/etcdctl /usr/local/bin/ COPY --from=etcd /usr/local/bin/etcdutl /usr/local/bin/ COPY --from=etcd /etc/nsswitch.conf /etc/nsswitch.conf CMD ["/usr/local/bin/etcd"]

Service registry and discovery etcd, consul, nacos

Yes, Kubernetes, in fact, relies on a number of other free and open source software packages. As a base, it relies on the Docker container runtime and the CoreOS Linux distribution, and it utilizes other open source projects for a number of its components, such as etcd for distributed key-value storage. The tool's core and control plane are both built in GO programming language, making it a completely Go-based application. Kubernetes itself is an open source project and has been used as a building block for other open source projects.

APISIX stores its configuration in etcd

Interesting. What are you thoughts on NSQ?

https://github.com/nsqio/nsq

Was looking at it earlier today, but haven't ever tried it out.

(G)NATS can do millions of messages per second and is the right tool for the job (either that or NSQ). Redis isn't even the fastest Redis protocol implementation, KeyDB significantly outperforms it.

Bit.ly's NSQ is also an excellent message queue option.

Queue consumers are interesting because there are many solutions for them, from using Redis and persisting the data in a data store - but for fast and scalable the approach I would take is something like SQS (as I advocate AWS even free tier) or NSQ for managing your own distributed producers and consumers.

distrubition server engine ( for example websocket server multi ws gateway and worker pool,nsq.io realtime message queue and so on)

NSQ is a message queue implemented by Golang, and all messages are routed through NSQ. Reasons for choosing NSQ compared to other MQs: decentralized distribution (direct connection between production and consumption), low latency, No ordering, high performance, simple binary protocol.

If we are talking about "cloud-native", I would really recommend taking a look at nsq or nats. I am really big fanboy of NSQ [1], it is simple, easy to setup and conceptually easy to learn.

[1] https://nsq.io

Here is link number 1 - Previous text "NSQ"

I've been using NSQ in production for a number of years now. It's also written in Go and has a first class client library maintained by the devs