Kops: Kubernetes the Easy Way
For those who are new to Kubernetes (commonly known as k8s) and want to begin playing around with their first pods, services, and deployments, there are many tutorials available for setting up a k8s installation using Minikube on their personal computers. While this is a great way to initially get experience working with k8s, eventually one will need to introduce their application stack to a production environment. Launching in a cloud environment like Google Cloud Platform (GCP) or Amazon Web Services (AWS) is facilitated using kops.
Keep reading
5 Caveats Before Diving into Reactive Microservices Architecture
We have been pushing reactive microservices for some time now, but there are some considerations to take note of before taking the plunge. Reactive microservices bring a lot of benefits to the the table, but it comes at a cost. Here are some caveats that you should be aware of as you transition away from monoliths…
Keep reading
Get Your Apps to the Poll (Phase)!
A month ago, I wrote about my investigation into an implementation of a real-time socket data manipulator which could eventually stall our application. While trying to research how this stuff actually worked, I couldn’t find many resources explaining how actual code goes through the event loop. Honestly, I think that’s a huge problem. I’m afraid most developers don’t understand the most critical part of Node.js, but I’m here to fix that. So, how do sockets work? How does the socket data get so backed up? Why does using a Transform solve the issue when piping with an async function does not?
Keep reading
How To Achieve Practical End-to-End Testing With Docker Compose
Now that Kubernetes and Docker support software-defined orchestration, end-to-end (E2E) testing has finally become a practical reality. We’ll walk through the biggest issue with maintaining and running E2E tests: the speed and hassle of spinning up a full-stack environment. Then we’ll cover how containerization solves single service environment problems, but not the full-stack environment problems E2E tests need. And finally, introduce software-defined orchestration as the panacea and exemplify the practicality of this approach through an example.
Keep reading
Error-Handling in Event-Based Systems
Different architectures and patterns are all about different tradeoffs. More specifically, they’re about transferring and transforming complexity from one place to another, and from one type into another. The same is of course true about the event-driven architecture that we use here at Runnable.
Let’s dive into where event-driven architecture reduces complexity and where it makes things more difficult. Warning: lots of code ahead.
Keep reading
Using Promises to Escape Callback Hell
Promises are at least 5 kinds of awesome. Functionally they are not all that different from callbacks, but those differences resolve code structure problems caused by the more traditional async library and callback approach. They also change the way we approach development.
Keep reading
Introducing Kontainer: The Easy Way to Switch to Kubernetes
Unless you’ve been hiding in a container for the past few months, you’ve probably heard of Kubernetes (often called k8s), the best container orchestration tool around. K8s configuration is a bit more involved than a simple Docker run command or Compose definition. However, in return for this complexity, you get a cluster that is fault tolerant, self-healing, and auto-scalable. If you are looking to move from native Docker tooling to k8s, I’ve created a tool for you!
Keep reading
How To Use Let’s Encrypt on Kubernetes to Automatically Generate Certs
HTTPS is an extremely important part of deploying applications to the web. It ensures encrypted transport of information between client and server. It can be complicated to set up, but Let’s Encrypt helps solve this problem by providing free SSL/TLS certificates and an API to generate these certificates. Kubernetes allows you to define your application runtime, networking, and allows you to define your infrastructure declaratively through code; making it easier to maintain, review, and share.
Keep reading
