CodeIsGo.com

Ovie Okeh is the author of this article on logrocket.com about a journey from monolithic apps running on a server to flexible units running on ephemeral instances. So why is the serverless popular? What does the term serverless mean?

All serverless means is that you can ship code to your users without having to worry about the underlying architecture required to run it. There is still a server running your code somewhere, but you don’t have to worry about setting it up or managing it. Serverless in a nutshell: “Let someone else be your DevOps team.

The article then make discovery on:

• Servers and why you need one
• The gross inefficiency of a traditional server
• Benefits of a serverless architecture
• Trakkr on serverless (case study)
• Trade-offs of going serverless
• Should you switch to a Serverless architecture?

The decision to adopt an architecture should not be based on a single article. However, the aim of this section is to provide you some of the questions you should be asking if you’re considering adopting a serverless architecture. Excellent!

Visual Studio is an Integrated Development Environment (IDE) developed by Microsoft which is used to code,debug and run the respective applications. Visual Studio supports around 36 programming languages (at time of writing) and the advantage of using Visual Studio is that the code editor and debugger will support all these programming languages and also it supports cross-platform. By Suhas Parameshwara.

The article provides some interesting tips and tricks that can be used in Visual Studio:

• Project templates
• Code snippets
• Document health indicator
• Code cleanup
• IntelliCode
• Vertical selection
• Solution filter

… and more. For full list click to the original article. Nicely done!

Aggregator Leaf Tailer (ALT) is the data architecture favored by web-scale companies, like Facebook, LinkedIn, and Google, for its efficiency and scalability. In this blog post, I will describe the Aggregator Leaf Tailer architecture and its advantages for low-latency data processing and analytics. By Dhruba Borthakur.

The biggest advantage of the Lambda architecture is that data processing occurs when new data arrives in the system, but ironically this is its biggest weakness as well. Most processing in the Lambda architecture happens in the pipeline and not at query time. As most of the complex business logic is tied to the pipeline software, the application developer is unable to make quick changes to the application and has limited flexibility in the ways he or she can use the data. Having to maintain a pipeline just slows you down.

The article then goes about:

• Traditional Data Processing: Batch and Streaming
• Common Lambda Architectures: Kafka, Spark, and MongoDB/Elasticsearch
• Shortcomings of Lambda Architectures
• ALT: Real-Time Analytics Without Pipelines
• Advantages of ALT
• Why ALT Makes Sense Today

The ALT architecture enables the app developer or data scientist to run low-latency queries on raw data sets without any prior transformation. A large portion of the data transformation process can occur as part of the query itself. The ALT architecture clearly has the performance, scale, and efficiency to handle real-time use cases at some of the largest online companies. Excellent read!

The Repository pattern is used to create a middle layer between a data layer (which can be a database, a file, a CSV, etc) and your controllers. It is mainly used on large scale application, where there will be dozens of reference to a single data layer. It gives the ability to change the data layer without affecting any code in your controller. By Anastasio Nico.

The repository pattern probably is best known for its widespread use within MVC application. In a normal application the flow works like this: The users reach a view or an endpoint requesting some data, this request need to be processed by a controller that in the majority of the cases will communicate with a source of data. Usually, that would be a database.

Repository pattern may be considered structural because of its similarity with the Facade pattern but at the same time, it is kinda creational because with some easy addition can look like a Factory.

For the example of the code in PHP and further explanation how it can be implemented follow the link to the original article. Nice one!

Fernando Amezcua put together this tutorial how to implement React Hooks creating the example project. React Hooks, TypeScript and Redux for React Native, and author is going to add testing for React Native.

You are going to build a counter app. This exercise consists of two buttons that increment or decrement the state of our app. You are going to implement Hooks to see the benefits of using them, and how to integrate TypeScript and Redux. Then, you are going to test with Jest.

Redux is a package that helps us create only one state into our app. The only way to change the state is through dispatch actions.

The tutorial describes:

• Getting started with TypeScript
• Install environment
• Redux
• How does it work?
• Actions
• Type
• Reducers

… and more. Reducers help us specify how the state will change. They are a response to the actions sent to the store. The actions describe what happened, they do not describe how the state will change. Easy read with plenty of code examples!

There are several best practices for building microservices architecture properly. In this article author mentions the best practices with some new rules dedicated especially for microservices deployed on Kubernetes platform. By Piotr Minkowski.

The first question is if it makes any difference when you deploy your microservices on Kubernetes instead of running them independently without any platform? Well, actually yes and no… Yes, because now you have a platform which is responsible for running and monitoring your applications, and it launches some its own rules. No, because you still have microservices architecture, a group of loosely coupled, independent applications, and you should not forget about it!

What you will find in the article:

• Allow platform to collect metrics
• Prepare logs in right format
• Implement both liveness and readiness health check
• Consider your integrations
• Use service mesh
• Be open for framework specific solutions
• Be prepared for a rollback

… and more. You will also get sample Spring Boot application that implements currently described best practices and is written in Kotlin. It is available on GitHub in repository sample-spring-kotlin-microservice under branch kubernetes.

In this tutorial, Luke Harrison shows you step by step how to create a simple tool in Node.js to run Google Lighthouse audits via the command line, save the reports they generate in JSON format and then compare them so web performance can be monitored as the website grows and develops.

If a previous report already exists for the same website when a Lighthouse audit is complete, automatically perform a comparison against it and show any changes to key performance metrics.

The article is split into these sections:

• What is Google Lighthouse?
• Setup
• Opening Chrome with Node.js
• Running Lighthouse programmatically
• Saving Lighthouse reports
• Comparing Lighthouse reports

… and much more. You will also get complete source code for this detailed tutorial. Superb!

Security research software engineer Yossi Weizman put together this guide for considering new security challenges when moving workloads to Kubernetes.

The MITRE ATT&CK® framework is a knowledge base of known tactics and techniques that are involved in cyberattacks. Started with coverage for Windows and Linux, the matrices of MITRE ATT&CK cover the various stages that are involved in cyber attacks (tactics) and elaborate the known methods in each one of them (techniques).

MITRE ATT&CK framework tactics include:

• Initial access
• Execution
• Persistence
• Privilege escalation
• Defense evasion
• Credential access
• Discovery
• Lateral movement
• Impact

When Azure Security Center started to map the security landscape of Kubernetes, they noticed that although the attack techniques are different than those that target Linux or Windows, the tactics are actually similar. To get full picture read this excellent article in full!

In this tutorial author will show you how to build a GitOps pipeline for a Node.js application built with Express.js. The application was created in an earlier tutorial. Rather than deploying new versions manually, flux will deploy it to Kubernetes whenever a build of the Docker image is available. By Alex Ellis.

The article also goes through:

• Why FluxCD and what are the alternatives?
• How to get and run Kubernetes cluster
• How to get and install Helm 3
• Sample app, config repo and HelmRelease
• Automate deployments for new versions

At the end of the tutorial, every new version of our app will be automatically updated in the cluster. What’s more, if we delete our cluster by accident, we can recover quickly because all of our resources are defined in our Git repository. This means we can easily re-create them in a new cluster.

You will also get plenty of links to further resources and link to GitHub repository with all the code. Also check an earlier tutorial for the app deployed: Guide to Helm 3 With an Express.js Microservice. Marvelous!

We’re using GitlabCI and a manual GitOps approach to implement and perform Canary Kubernetes deployments. They use a manual approach and alter/create core-Kubernetes resources to perform a Canary deployment. This is mainly for understanding how a Canary deployment works. By Kim Wuestkamp.

In a Canary deployment, new changes are first deployed to a subset of users. Through monitoring, logging, manual testing or other feedback channels the release is tested before it is rolled out to all users.

The default strategy for a Kubernetes Deployment is rolling-update, where a certain number of pods with the new image version are spun up. If these were created without issues, pods of the old image version are terminated and new pods are created simultaneously.

Also in this article:

• GitOps – Git as single source of truth
• Example with
  • Application repo
  • Infrastructure repo
  • Infrastructure yaml
• How to perform initial deployment
• How to perform a Canary deployment

Running through this kind of deployment manually helps understanding how easily this can be configured using kubernetes. The author has more interesting articles on this topic, so please follow the link to full text. Nice one!