Load Balancer vs. Reverse Proxy vs. API Gateway

Are you struggling to understand the differences between load balancers, reverse proxies, and API gateways? Unsure which component is best suited for your web application? You’re not alone! These key components play vital roles in modern web architectures, and knowing how they work is essential for building efficient, secure, and scalable web applications. In this blog, we’ll demystify these concepts and help you make informed decisions for your next project.

Imagine a busy restaurant: the load balancer acts as the headwaiter, ensuring diners are seated evenly to optimize service; the reverse proxy is the skilled waiter who streamlines orders and ensures the best possible experience for each guest; and the API gateway is the restaurant manager who oversees and controls every aspect of the dining experience. Now, let’s translate this analogy into the world of web applications.

Did you know that websites like Amazon and Netflix handle billions of requests every day? With such massive traffic, distributing the load effectively is crucial. Enter the load balancer, which optimizes performance and ensures high availability. But how do load balancers differ from reverse proxies? And when should you use each component? We’ll dive deep into these questions and more.

Lastly, we’ll explore the powerful API gateway, a crucial component in microservices architecture. It centralizes the management, security, and scalability of APIs, ensuring seamless interaction between numerous microservices. But how does the API gateway compare to load balancers and reverse proxies? Stay tuned to find out!

Load Balancer

Have you ever wondered how large-scale web applications handle millions of requests without crumbling under the pressure? The secret lies in the efficient use of load balancers, which ensure optimal resource utilization, maximize throughput, and minimize response time. Let’s dive into the world of load balancing and discover how it can transform your web application.

Load Balancer

a. Layer 4 vs. Layer 7 load balancing

Did you know that load balancers can operate at different layers of the OSI model? Layer 4 load balancers work at the transport layer, making decisions based on network-level information such as IP addresses and TCP/UDP ports. On the other hand, Layer 7 load balancers operate at the application layer, leveraging HTTP headers, cookies, and URL paths to make more granular decisions. Which approach is best for your application? It depends on your specific needs and requirements, but understanding the distinction is crucial.

b. Load balancing algorithms

So, how do load balancers distribute traffic? They use various algorithms to achieve the best possible distribution. For example, the Round Robin algorithm cycles through available servers, while the Least Connections algorithm directs traffic to the server with the fewest active connections. The Consistent Hashing algorithm, used by many content delivery networks, maps requests to servers based on the request’s hash value, ensuring that similar requests are served by the same server. The choice of algorithm can significantly impact your application’s performance and scalability.

c. Benefits

The benefits of load balancing are immense. For instance, consider the e-commerce giant Amazon, which handles over 2 million transactions per hour. Load balancers play a pivotal role in ensuring high availability and fault tolerance, distributing the workload evenly and rerouting traffic in case of server failures. This keeps your application running smoothly, even during peak traffic times or server outages.

But what about security? Load balancers can also help protect your application from distributed denial-of-service (DDoS) attacks. By distributing traffic evenly and monitoring for unusual patterns, load balancers can detect and mitigate potential threats, safeguarding your application from downtime and performance issues.

d. Summary

In summary, load balancers are essential components for building efficient, secure, and scalable web applications. By understanding their operation, algorithms, and benefits, you can make informed decisions and harness the full potential of load balancing in your projects. Don’t let your application crumble under the pressure of high traffic — embrace load balancing and watch your web application soar to new heights!

System Design Interview Survival Guide (2023): Preparation Strategies and Practical Tips

System Design Interview Preparation: Mastering the Art of System Design.


Reverse Proxy

Are you looking to enhance the security, performance, and maintainability of your web application? Look no further than the reverse proxy, a versatile and powerful component that can streamline your application and provide a myriad of benefits. Let’s explore how reverse proxies work and why they’re essential for modern web architectures.

Reverse Proxy

a. Operation at Layer 7 (application layer) of the OSI model

Did you know that reverse proxies operate at Layer 7 (application layer) of the OSI model? This means they handle requests and responses at the HTTP level, enabling them to offer advanced features and functionality. For example, reverse proxies can perform URL rewriting, which simplifies complex URLs and improves SEO. But what other benefits can reverse proxies bring to the table?

b. Functionality and Benefits

Imagine offloading resource-intensive tasks, such as SSL termination and content compression, from your backend servers. Reverse proxies can handle these tasks, freeing up your servers to focus on their core responsibilities. The result? Improved performance and reduced server load.

Security is a paramount concern for any web application. Reverse proxies can act as a shield, filtering incoming requests and protecting your backend servers from malicious traffic. By implementing access controls and monitoring requests for suspicious activity, reverse proxies can fortify your application’s security and safeguard sensitive data.

But did you know that reverse proxies can also improve the maintainability of your application? By providing a single point of access, reverse proxies simplify server management and make it easier to scale your application. As your application grows, you can add or remove backend servers without affecting the client-facing interface, streamlining the process of scaling up or down.

Consider the case of GitHub, a popular platform for software development. With millions of users and countless repositories, GitHub relies on reverse proxies to ensure efficient operation and maintain high performance. By offloading tasks like SSL termination and caching, reverse proxies play a crucial role in delivering a seamless user experience.

c. Summary

In conclusion, reverse proxies are indispensable components for building secure, high-performance, and maintainable web applications. By understanding their operation and the benefits they offer, you can harness the full potential of reverse proxies and take your web application to new heights. So, why wait? Embrace the power of reverse proxies and transform your application today!

API Gateway

Are you building a microservices-based application and searching for an efficient way to manage and secure your APIs? The API gateway is the ultimate solution for centralizing management, enhancing security, and ensuring scalability. Join us as we explore the power of API gateways and learn how they can revolutionize your application.

What exactly is an API gateway? In a nutshell, it’s a server that acts as a single entry point for all API calls from clients to your backend services. It’s like the conductor of an orchestra, coordinating all the individual instruments to create a harmonious performance. But what features can API gateways offer to elevate your application?

API Gateway

a. Features and Benefits

Authentication is crucial for securing your APIs, and API gateways excel at this task. By implementing centralized authentication and authorization, API gateways eliminate the need to duplicate security measures across multiple services, simplifying security management and reducing the risk of vulnerabilities.

Have you ever struggled with managing the rate at which clients access your APIs? API gateways can enforce rate limiting, ensuring that your backend services remain stable and performant even during periods of high demand. This helps prevent system overload and ensures a consistent user experience.

How about transforming requests and responses on-the-fly? API gateways can modify requests and responses as needed, allowing you to modify API payloads, convert between data formats, or add custom headers. This adds flexibility and adaptability to your application, making it easier to evolve over time.

Monitoring and logging are essential for maintaining a healthy application, and API gateways have you covered. By providing centralized monitoring and logging capabilities, API gateways make it easy to track performance, diagnose issues, and identify trends across your entire application.

Take the case of Netflix, a global streaming giant with over 200 million subscribers. Netflix relies on API gateways to manage its extensive microservices architecture, providing a scalable and secure solution for handling millions of API calls every day.


In summary, API gateways are powerful tools for managing, securing, and scaling your APIs in a microservices architecture. By understanding their features and benefits, you can harness the full potential of API gateways and build applications that are both robust and flexible. So, what are you waiting for? Embrace the power of API gateways and elevate your application to new heights!

Comparing Load Balancer, Reverse Proxy, and API Gateway

Do you find yourself confused when trying to differentiate between load balancers, reverse proxies, and API gateways? You’re not alone! These components share some similarities but serve distinct purposes in modern web architectures. Let’s delve into their key differences and learn how to choose the right component for your application.

a. Key differences in purpose, operation, and features

How do load balancers differ from reverse proxies? While both components distribute requests, load balancers primarily focus on improving performance, availability, and fault tolerance by distributing traffic among multiple backend servers. Reverse proxies, on the other hand, operate at the application layer and offer additional functionality such as URL rewriting, content compression, and access control. So, when should you choose a load balancer or a reverse proxy? It depends on your specific requirements and whether you need advanced application-level features.

But what about API gateways? How do they fit into the picture? API gateways are best suited for microservices architectures, where multiple APIs need centralized management, security, and scalability. Unlike load balancers and reverse proxies, API gateways offer advanced features like authentication, rate limiting, request/response transformation, and monitoring. If your application relies heavily on APIs, an API gateway is an invaluable addition to your architecture.

API Gateway vs. Load Balancer

b. Combining components for optimal web architectures

Can you combine these components for optimal results? Absolutely! In many cases, you’ll find load balancers, reverse proxies, and API gateways working in harmony to create efficient, secure, and scalable web applications. For example, you could use a load balancer to distribute traffic among multiple reverse proxies, which in turn secure and optimize requests to your backend services. Alternatively, you might use an API gateway in conjunction with a load balancer to manage and scale your APIs while maintaining high availability.

Consider the case of Spotify, a leading music streaming platform. Spotify employs a combination of load balancers, reverse proxies, and API gateways to handle millions of daily requests, ensuring a seamless and enjoyable experience for its users.

c. Summary

In conclusion, understanding the unique aspects of load balancers, reverse proxies, and API gateways is crucial for building modern web applications. By comparing their purposes, features, and use cases, you can make informed decisions and choose the right components for your application. Don’t let confusion hold you back — embrace these powerful tools and take your web architecture to the next level!

Popular Tools and Solutions

Are you eager to dive into the world of load balancers, reverse proxies, and API gateways but unsure which tools to use? Fear not! Here is a list of popular and powerful solutions that can help you build and optimize your web application. Let’s explore these industry-leading tools and discover the perfect fit for your needs.

a. Load balancers: HAProxy, NGINX, Amazon ELB

When it comes to load balancers, you can’t go wrong with HAProxy, an open-source, high-performance TCP/HTTP load balancer. Trusted by tech giants like GitHub and Stack Overflow, HAProxy provides a wide range of features, including Layer 4 and Layer 7 load balancing, SSL termination, and health checks. Looking for a cloud-based solution? Check out AWS Elastic Load Balancing, which offers application and network load balancing for Amazon Web Services applications.

b. Reverse proxies: NGINX, Apache HTTP Server, Microsoft IIS

What about reverse proxies? One standout option is NGINX, an open-source web server, reverse proxy, and load balancer all rolled into one. With its high performance and extensive feature set, NGINX is an ideal choice for securing and optimizing your web application. Alternatively, you might consider Apache HTTP Server with its mod_proxy module, which provides reverse proxy functionality for the widely used web server.

c. API gateways: Kong, Amazon API Gateway, Apigee

In the realm of API gateways, look no further than Kong, an open-source, high-performance API gateway built on top of NGINX. With its extensive plugin ecosystem and support for custom plugins, Kong allows you to tailor your API gateway to your application’s unique requirements. If you prefer a fully managed, cloud-based solution, consider Amazon API Gateway, which provides a serverless API management platform with robust security, monitoring, and scaling capabilities.

Curious about container orchestration platforms? Kubernetes, the popular open-source container orchestration platform, offers built-in support for load balancing, reverse proxies, and API gateways through its Ingress and Service resources, making it an excellent choice for containerized applications.

d. Summary

In conclusion, the world of load balancers, reverse proxies, and API gateways is filled with powerful and flexible tools to suit every need. By exploring popular solutions like HAProxy, NGINX, Kong, and Kubernetes, you can make informed decisions and find the perfect tools for your web application. Don’t let uncertainty hold you back — embrace these cutting-edge solutions and elevate your web architecture today!


In conclusion, navigating the intricate world of load balancers, reverse proxies, and API gateways can be a daunting task, but armed with the right knowledge, you’re now equipped to make informed decisions and choose the perfect components for your web application. Remember that load balancers distribute traffic among multiple backend servers, reverse proxies offer additional application-level features, and API gateways provide centralized management and security for microservices-based applications.

Next, don’t hesitate to mix and match these components for optimal results. By combining load balancers, reverse proxies, and API gateways, you can build a web architecture that is efficient, secure, and scalable. Embrace the power of these components and unlock the full potential of your application.

Furthermore, explore the wide array of powerful tools and solutions available, such as HAProxy, NGINX, Kong, and Kubernetes. Each tool offers unique benefits, features, and use cases, allowing you to find the perfect fit for your application. Leverage these industry-leading tools and stay ahead of the curve.

Finally, remember that the technology landscape is ever-evolving, and staying up-to-date with the latest advancements, trends, and best practices is crucial for building cutting-edge web applications. Continuously learn, experiment, and innovate to ensure your application remains competitive and future-proof.

As you embark on your journey to build a robust, high-performance web application, take these lessons to heart and apply them in your projects. By understanding the power of load balancers, reverse proxies, and API gateways, and leveraging the best tools and practices, you can elevate your web architecture and create extraordinary experiences for your users. So, what are you waiting for? Embrace the world of load balancers, reverse proxies, and API gateways, and transform your application today!

Techniques for Scaling Applications with a Database

Applications grow. As an application attracts more users, so do the databases that store the information created, whether that’s sales transactions or scientific data gathered. Larger datasets require more resources to store and process that data. Plus, with more simultaneous users using the system, the database needs more resources.

When your application becomes popular, it needs to scale to meet the demand. Nobody sticks around if an application is slow — not willingly, anyway.

If you need to scale, celebrate it as a good problem! But that doesn’t make the process simple. Scaling has multiple possible options, each requiring different levels of sophistication. Here, we cover scaling both as a generic challenge and specifically for Redis databases, with attention to advanced scaling using Redis Enterprise.

Scaling Concepts

Scaling is a multidimensional problem with several distinct solutions.

Vertical scaling involves increasing a database’s resources. Typically, this involves moving the database to a more powerful computer or to a larger instance type.

“More” is the key word. As with any hardware choice, you consider more powerful processors, more memory and/or more network bandwidth. You have to find a balance between them that optimally improves the database’s performance and the number of simultaneous users it can support, not to mention optimizing your hardware budget.

One element in vertical scaling is adjusting the amount of RAM available to the database. In the case of Redis, RAM limits the amount of data that the database can store, so it’s an important consideration.

Vertical scaling is colloquially called scaling up or scaling down, depending on whether you move up to a more powerful computer or (in rare circumstances) shift down to a less powerful computer.

Redis provides a competitive edge to any business by delivering open source and enterprise-grade data platforms to power applications that drive real-time experiences at any scale. Developers rely on Redis to build performance, scalability, reliability, and security into their applications.

Learn More


Setting New Benchmark in Partner Enablement

23 February 2023
Redis Enterprise 6.4.2 Highlights Client Validation and Access Management Features
23 February 2023
Techniques for Scaling Applications with a Database
22 February 2023

Horizontal scaling involves adding additional computer nodes to a cluster of instances that operate the database, without changing the size or capacity of any individual node. Horizontal scaling is also called scaling out (when you add nodes) or scaling in (when you decrease the number of nodes).

Depending on how it’s implemented, horizontal scaling can also improve the database’s overall reliability. It eliminates a single point of failure because you are increasing the number of nodes that can be used in failover situations. However, horizontal scaling also increases time and effort (and thus costs), because you need more nodes (and hence more failure points) to keep the database functional.

In other words, vertical scaling increases the size and computing power of a single instance or node, while horizontal scaling changes the number of nodes or instances.

Vertical scaling is an easy way to improve database performance, assuming that you have or can acquire a larger computer or instance. It typically can be implemented easily in the cloud, with no impact on the application or database architecture.

Complexity isn’t a bad thing when it’s the right choice, as long as you know what you are doing.

When done correctly, horizontal scaling gives your database and your application significantly more room to grow. This scheme has plenty of history in responding to performance bottlenecks: Just throw more hardware at it!

However, horizontal scaling typically is harder to implement than vertical scaling. Adding additional nodes means more complexity. Are those nodes read-only nodes? Read/write master nodes? Active masters? Passive masters? The complexity of your database and your application architecture can increase dramatically.

Complexity isn’t a bad thing when it’s the right choice, though, as long as you know what you are doing.

There are several ways to implement horizontal scaling, each with a distinct set of advantages and disadvantages. Selecting the right model is important in building a data storage architecture. Redis supports many horizontal scaling options. Some are available in Redis open source (OSS), and some are available only in Redis Enterprise.

The Basics of Sharding

Sharding is a technique for improving a database’s overall performance, as well as increasing its storage and resource limits. It’s a relatively simple horizontal scaling technique.

With sharding, data is distributed across various partitions, or nodes. Each node holds only a portion of the data stored in the entire database. In Redis’ case, a key/value input is processed, and the data is stored in a shard.

When a request is made to the database, it is sent to a shard selector, which chooses the appropriate shard to send the request. In Redis, shard selection is often implemented by a proxy that looks at the key for the requested data, and based on the key, the proxy sends the request to the appropriate shard instance.

The shard selection algorithm is deterministic, which means every request for a given key always goes to the same shard. Only that shard has information for a given data key, as illustrated by Figure 1.

Figure 1. Horizontal scaling via sharding

Sharding is a relatively easy way to scale out a database’s capacity. By adding three shards to a Redis OSS implementation, for instance, you can nearly triple the database’s performance and triple the storage limits.

But sharding isn’t always simple. Choosing a shard selector that effectively balances traffic across all nodes may require tuning. Sharding can also lower application availability because it increases dependency on multiple instances. If you don’t manage it properly, failure of a single instance can bring down the entire database. That’ll cause a bad day at work.

Redis clustering addresses these issues, and also makes sharding easier to implement. If resharding is necessary to rebalance a database for reasons of storage capacity or performance, the data is physically moved to a new node.

An application’s awareness of the shard selector algorithm can allow the application to perform better overall balancing across the shards, though at the cost of increased complexity.

Sharding effectiveness is only as good as the shard selector algorithm that is used. An application’s awareness of the shard selector algorithm can allow the application to perform better overall balancing across the shards, though at the cost of increased complexity.

Clustering in Redis OSS is led by the cluster with the client library being cluster-aware. Essentially, the shard selector is implemented in the client library. This requires client-side support of the clustering protocol.

In Redis Enterprise, a server-side proxy is used to implement the shard selector and to provide support for clustering server side. The proxy acts as a load balancer of sorts between the horizontally scaled Redis instances.

Clustering is a common solution to horizontal scaling, but it has pros and cons. On the plus side, sharding is an effective way to quickly scale an application, and it is used in many large, highly scaled applications. Also, it is available out of the box.

On the other hand, clustering requires additional management. You need to know what you’re doing. Individual, large keys can create imbalances that are difficult or impossible to compensate for.

Redis clustering eliminates much of shardings’ complexities. It allows applications to focus on the data management aspects of scaling a large dataset more effectively. It improves both write and read performance.

Ultimately, how well it all works depends on the access patterns that the application uses.

Read Replicas

Another horizontal scaling option is read replicas. As the name suggests, the emphasis of read replicas is to improve the performance of reading data without regard to the time spent writing data to the database. The premise is that it is far more common to retrieve data than to change it or to add new data.

In a simple database, data is stored on a single server, and both read and write access to the data occurs on that server. With read replicas, a copy of the server’s data is stored on auxiliary servers, called read replicas. Whenever data is updated, the replicas receive updates from the primary server.

Each auxiliary server has a complete copy of the database. So when an application makes a read request, that request can go to any of the read replica servers. That means a significantly greater number of read requests can be handled simultaneously, which improves scalability and overall performance.

Read replicas cannot improve write performance, but they can increase read performance significantly.

But read replicas have limitations, depending on several factors, such as the consistency model that the database uses, or the network latency you need to contend with.

Read replicas cannot improve write performance, but they can increase read performance significantly. However, that does require you to consider how write-intensive your application is. It takes some time for a database write to the master database to propagate to the read replicas. This delay, called skew, can result in older data being returned to the application while the primary server updates the replica servers. The delay is only for a short period of time, but sometimes those delays are critical. This may or may not be an issue for your own situation, but take note of the issue as you design your system.

Think about the process of writing to a database.

  • When you update information or add new data, the write is performed to the master database instance only. That’s sacrosanct; all writes must go to the one master database instance.
  • This master instance then sends a message to all of the read replicas, indicating what data has changed in the database, and enabling the read replicas to update their copies of the data to match the master copy.

Since all database writes go through the master instance, there is no write performance improvement when additional read replicas are added. In fact, there can be a minor decrease in write performance when you add a new read replica. That’s because the master now has an additional node it must notify when a write occurs. Typically, this impact is not significant, but it’s certainly not a zero impact.

Consider the illustration in Figure 2, which shows a Redis implementation consisting of three servers. All writes to the Redis database are made to the single master database. This single master sends updates of the changed data to all the replicas. Each replica contains a complete copy of the stored Redis database.

Then, when the application wants to retrieve data, the read access to the Redis instance can occur on any server in the cluster. A load balancer takes care of routing the individual read requests, which directs traffic using one of a number of load balancing algorithms. (There are several load balancing algorithms, including round robin, least used, etc., but they are outside the scope of this discussion.)

Figure 2. Horizontal scalability with read replicas

Another benefit to using read replicas is in availability improvement. If a read replica crashes, the load balancer simply redirects traffic to another read replica. If the write master crashes, you can promote one of the read replicas to the role of master, so the system can stay operational.

Read replicas are an easy-to-implement model for horizontal scalability, and the method improves availability with little or no application impact.


Active-Active replication or Active-Active clustering is a way to improve performance for higher database loads.

As with read replicas, Active-Active (also called multimaster replication) relies on a database cluster with multiple nodes, with a copy of the database stored on all the nodes and a load balancer distributing the load.

With Active-Active replication, however, both read and write requests are distributed across multiple servers, and load balanced among all the nodes. The performance boost is meaningful, because a significantly larger number of requests can be handled, and they are handled faster.

Note that Active-Active replication is not supported directly by Redis OSS. If this turns out to be the appropriate scaling architecture for your needs, you’ll need Redis Enterprise. But the focus here is in explaining the computer science technique, no matter where you get it from (including building it yourself, if you have that sort of time).

With Active-Active replication, the read propagation happens exactly as described in the previous section.

When an application writes to one node, this database write is propagated to every master in the system. There are many ways this can occur, such as:

  • The application can force the write to all masters.
  • A write proxy can distribute the writes.
  • The master node that receives the write call can forward the request to other non-receiving master servers.

Figure 3 illustrates a database implementation with a cluster consisting of three servers. Each server contains a complete copy of all the data. Any server can handle any type of data request — read or write — for any data in the database.

Figure 3. Active-Active replication

When the load balancer directs a write request to the database master instance, such as in this example, it sends the update to all the other replicated instances. If a write is sent to any of the other nodes, that node sends the update to all the other replicated instances in a similar manner.

But what happens when two requests are sent to update the same data value?

In a single-node database, the requests are serialized and the changes take place in order, with the last change typically overriding previous changes.

In the Active-Active model, though, the two requests could come to different masters. The masters could then send conflicting update messages to the other master servers. This is called a write conflict.

In the case of a write conflict, the application needs to determine which database-write to keep and which to reject. That requires a resolution algorithm of some type, involving application logic or database rules.

Additionally, since updates are sent to each node asynchronously, it’s possible for data lag to cause one node to go slightly out of sync with another node. That’s an issue even when that mismatch is only for a short period of time. Developers have to take care that the application considers this potential lag so that it does not affect operations. This is similar to the issues with read replicas, but is potentially more complex.

Besides improving performance, this model of horizontal scalability also increases overall database availability. If a single node fails, the other nodes can take up the slack. However, since each node contains a complete copy of the data, this has no impact on the storage limit of a database by adding additional servers.

The cost of this model is increased application complexity in dealing with conflicting data.

Redis Enterprise’s Active-Active Geo-Distribution

Redis OSS does not natively support multimaster redundancy in any form.

However, Redis Enterprise does Active-Active Geo-Distribution, which provides Active-Active multimaster redundancy.

Then Redis Enterprise’s Active-Active Geo-Distribution goes one step further. It enables individual clusters to be located in geographically distributed locations yet replicate data between them. Take a look at Figure 4.

Figure 4. Active-Active replication across geography

This allows a Redis database to be geographically distributed to support software instances running in different geographic locations.

In this model, multiple master database instances are in different data centers. Those can be located across different regions and around the world. Individual consumers, via the application, connect to the Redis database instance that is nearest to their geographic location. The Active-Active Redis database instances are then synchronized in a multimaster model so that each Redis instance always has a complete and up-to-date copy of the data.

Redis Enterprise’s Active-Active Geo-Distribution has sophisticated algorithms for effectively dealing with write conflicts, including implementing conflict-free, replicated data types (CRDTs) that guarantee strong eventual consistency and make the process of replication synchronization significantly more reliable. The application still must be aware of and deal with data lag and write conflicts, so these issues don’t become a problem.

What’s Right for You?

You need to make your applications run faster and support additional burden on their databases. Fortunately, as this article demonstrates, you have plenty of options for scaling techniques. Each has a different impact on the amount of storage space available to your application and on the system resources.

The technique you ultimately choose depends on many factors, including your company’s goals, your software requirements, the skills of the people in your IT department, your application architecture and how much complexity you’re willing to take on.

To learn more about how Redis Enterprise scales databases — with more diagrams, which are always fun — consult “Linear Scaling with Redis Enterprise.”


Learning GIT using McDonald’s

The most lightly taken & ignored skill: Git️️⚙️

Git process

When you go to McDonald’s🍔 & order a “Double Quarter Pounder Burger with whole wheat bread bun, some extra Cheese with less tomatoes slice & extra mayonnaise with a large Coke”🍔🍶
(By the way thats a huge burger man 😂)

The moment you place Order:

🍔 The manager will shout out your order within the team🗣️

🍔 2 3 people will start separately working on your order like one on chicken patty part, one on wheat bread bun, one on veggies & one on your soft drink so on🕴🏻🕴🏻

🍔 They all will first “Pull” the latest stock they have in their respective inventory like bread, veggies, chicken patty & all.

🍔 The moment all 3 4 guys are ready with their individual task, they come at a single place with their result🤌🏻😎

🍔 They will add & merge all their results in a wrapper

🍔 Then push it in a box & boom it will be handed over to you🥳

And This is how exactaly Git concept works‍✅🎉

The moment your Team gets a Project like “Create a Calculator”

👨🏻‍💻Your Team Lead will shout out the task within the Team➕✖️➗

👨🏻‍💻 2 3 developers, will start separately working on different features of Calculator like one on Addition➕, one on Division➗ & so on.

👨🏻‍💻They will first “Pull”, at present the latest code, of your project, from Github/Bitbucket or wherever your project is stored into their local machines💻💻

👨🏻‍💻 Once all 2 3 guys, are ready with their respective task, they all will “push” their code at a single place📥

👨🏻‍💻They will “merge” all their work & boom the Calculator is ready✅🎉

Lets now dig a bit deeper on the Practical & Processing part of Git🧙🏼‍♂️⚙️

Note: Keep patience for next 3 mints and read calmly, lets start😎️

The moment you are asked to code & add a new feature in your existing project code repo, you will first

🔥Clone the code repo by command : git clone

Your company will be storing their code in a repo on Github or Bitbucket, they will create your account as well there, so login into that account, go to the code repo and use the command

🧞‍♂”️git clone https://[email protected]/sample_repo.git -b develop”
The “-b develop” will clone the develop branch, from many other branches present in your main code repo of team.

🔥Now once you have project’s develop branch code, you will create your own branch from it (like your own working space)

🧞‍♂️git checkout -b mohit/feature_calculator_addition
“mohit/feature_calculator_addition” this branch is your private space, separated from your main team project, this will help to avoid any issue, from your side, in the main code of the team.

🔥Start doing the changes or code addition you want and once done do

🧞‍♂️git status : It will show all the scripts you have made changes to.

🧞‍♂️git add a.py b.py: This will add the changed script to a staging/space where they are made ready to be now pushed to main repo.

🧞‍♂️git commit -m “added addition feature”: This will be your msg to the team for the code you have worked on.

🧞‍♂️git push origin mohit/feature_calculator_addition: This will push your entire code to the branch you have created.

🔥Till now you have taken pull of the team’s code, created your own branch, worked on it, pushed the code to “your” branch.

But all this is at “your” level till now, so to put all this, in teams code repo you will raise a “Pull Request” to your Team Lead.

🔥Login to your Bitbucket/Github console -> Go to Pull Request tab,
select from where to where you want to move your code.
From: mohit/feature_calculator_addition To: Develop

🔥Once you raise the PR, by adding your team lead name, he will be notified & he can see your changes in all those scripts you have made.

🔥If he/she feels it’s proper, lead will accept your code & merge it in the teams’s develop branch or else he will reject it with a message by him & you will be notified why it’s been rejected & you will do the necessary changes & will raise a PR.

PR raised to Lead Emma from Your branch to Team Branch

🔥Also when you raise a PR, there can be a scenario where you and one other team member have made changes in the exact same script in exactly the same line, now this will give a “Merge Conflict” when code will be added to the main branch🤕

Merge conflicts happen when you merge two branches that have competing/smiliar commits, and Git needs your help to decide which/whose changes to incorporate in the final merge.

🔥You have to resolve this merge conflict, by either changing the code’s position or by deciding which one of you will be keeping your code on that paticular line giving merge conflict🥶

🥳Once resolved, the final code will be added to the project’s repo code🥳

🤷🏻‍♂️Now the most asked question: What is Git and GitHub ?🙄

See Internet is a concept, on which we are making and using Whatsapp, Facebook, Gmail🤖

Same way, Git is the concept, an approach on which Github & Bitbucket have opened their shops, of giving developer a space, where we can save our code & version them, so that if by chance we have issue in our Production code, we can just rollback to our second last release code & can publish it for customer🥳

There are many more, deep down things in Git, but this article’s approach was to just give you a brief idea, about the concept of git, so that later on it will be easy for you to connect dots about git by any tutorial you like🤌🏻😎

And Thank You for being here with me and for your love🫶🏻🙌🏻
It makes me so happy 😃 seeing a clap 👏🏻 or a comment✍🏻 or seeing article shared by someone. It makes all the efforts worth 🙏🏻

So that’s all from now, hope you have enjoyed the Git burger 🍔😂 as well the concept.
Wish you all a happy learning and an awesome year ahead🥳

Why i switched form docker desktop to Colima

DDEV is an open source tool that makes it simple to get local PHP development environments up and running within minutes. It’s powerful and flexible as a result of its per-project environment configurations, which can be extended, version controlled, and shared. In short, DDEV aims to allow development teams to use containers in their workflow without the complexities of bespoke configuration.

DDEV replaces more traditional AMP stack solutions (WAMP, MAMP, XAMPP, and so on) with a flexible, modern, container-based solution. Because it uses containers, DDEV allows each project to use any set of applications, versions of web servers, database servers, search index servers, and other types of software.

In March 2022, the DDEV team announced support for Colima, an open source Docker Desktop replacement for macOS and Linux. Colima is open source, and by all reports it’s got performance gains over its alternative, so using Colima seems like a no-brainer.

Migrating to Colima

First off, Colima is almost a drop-in replacement for Docker Desktop. I say almost because some reconfiguration is required when using it for an existing DDEV project. Specifically, databases must be reimported. The fix is to first export your database, then start Colima, then import it. Easy.

Colima requires that either the Docker or Podman command is installed. On Linux, it also requires Lima.

Docker is installed by default with Docker Desktop for macOS, but it’s also available as a stand-alone command. If you want to go 100% pure Colima, you can uninstall Docker Desktop for macOS, and install and configure the Docker client independently. Full installation instructions can be found on the DDEV docs site.

An image of the container technology stack.

(Mike Anello,CC BY-SA 4.0)

If you choose to keep using both Colima and Docker Desktop, then when issuing docker commands from the command line, you must first specify which container you want to work with. More on this in the next section.

More on Kubernetes

What is Kubernetes?

Free online course: Containers, Kubernetes and Red Hat OpenShift technical over…

eBook: Storage Patterns for Kubernetes

Test drive OpenShift hands-on

An introduction to enterprise Kubernetes

How to explain Kubernetes in plain terms

eBook: Running Kubernetes on your Raspberry Pi homelab

Kubernetes cheat sheet

eBook: A guide to Kubernetes for SREs and sysadmins

Latest Kubernetes articles

Install Colima on macOS

I currently have some local projects using Docker, and some using Colima. Once I understood the basics, it’s not too difficult to switch between them.

  1. To get started, install Colima using Homebrew brew install colima
  2. ddev poweroff (just to be safe)
  3. Next, start Colima with colima start --cpu 4 --memory 4. The --cpu and --memory options only have to be done once. After the first time, only colima start is necessary.
  4. If you’re a DDEV user like me, then you can spin up a fresh Drupal 9 site with the usual ddev commands (ddev config, ddev start, and so on.) It’s recommended to enable DDEV’s mutagen functionality to maximize performance.

Switching between a Colima and Docker Desktop

If you’re not ready to switch to Colima wholesale yet, it’s possible to have both Colima and Docker Desktop installed.

  1. First, poweroff ddev:ddev poweroff
  2. Then stop Colima: colima stop
  3. Now run docker context use default to tell the Docker client which container you want to work with. The name default refers to Docker Desktop for Mac. When colima start is run, it automatically switches Docker to the colima context.
  4. To continue with the default (Docker Desktop) context, use the ddev start command.

Technically, starting and stopping Colima isn’t necessary, but the ddev poweroff command when switching between two contexts is.

Recent versions of Colima revert the Docker context back to default when Colima is stopped, so the docker context use default command is no longer necessary. Regardless, I still use docker context show to verify that either the default (Docker Desktop for Mac) or colima context is in use. Basically, the term context refers to which container provider the Docker client routes commands to.

Try Colima

Overall, I’m liking what I see so far. I haven’t run into any issues, and Colima-based sites seem a bit snappier (especially when DDEV’s Mutagen functionality is enabled). I definitely foresee myself migrating project sites to Colima over the next few weeks.

Migrate databases to Kubernetes using Konveyor

Ships at sea on the web

Kubernetes Database Operator is useful for building scalable database servers as a database (DB) cluster. But because you have to create new artifacts expressed as YAML files, migrating existing databases to Kubernetes requires a lot of manual effort. This article introduces a new open source tool named Konveyor Tackle-DiVA-DOA (Data-intensive Validity Analyzer-Database Operator Adaptation). It automatically generates deployment-ready artifacts for database operator migration. And it does that through datacentric code analysis.

What is Tackle-DiVA-DOA?

Tackle-DiVA-DOA (DOA, for short) is an open source datacentric database configuration analytics tool in Konveyor Tackle. It imports target database configuration files (such as SQL and XML) and generates a set of Kubernetes artifacts for database migration to operators such as Zalando Postgres Operator.

A flowchart shows a database cluster with three virtual machines and SQL and XML files transformed by going through Tackle-DiVA-DOA into a Kubernetes Database Operator structure and a YAML file

DOA finds and analyzes the settings of an existing system that uses a database management system (DBMS). Then it generates manifests (YAML files) of Kubernetes and the Postgres operator for deploying an equivalent DB cluster.

A flowchart shows the four elements of an existing system (as described in the text below), the manifests generated by them, and those that transfer to a PostgreSQL cluster

Database settings of an application consist of DBMS configurations, SQL files, DB initialization scripts, and program codes to access the DB.

  • DBMS configurations include parameters of DBMS, cluster configuration, and credentials. DOA stores the configuration to postgres.yaml and secrets to secret-db.yaml if you need custom credentials.
  • SQL files are used to define and initialize tables, views, and other entities in the database. These are stored in the Kubernetes ConfigMap definition cm-sqls.yaml.
  • Database initialization scripts typically create databases and schema and grant users access to the DB entities so that SQL files work correctly. DOA tries to find initialization requirements from scripts and documents or guesses if it can’t. The result will also be stored in a ConfigMap named cm-init-db.yaml.
  • Code to access the database, such as host and database name, is in some cases embedded in program code. These are rewritten to work with the migrated DB cluster.


DOA is expected to run within a container and comes with a script to build its image. Make sure Docker and Bash are installed on your environment, and then run the build script as follows:

cd /tmp
git clone https://github.com/konveyor/tackle-diva.git
cd tackle-diva/doa
bash util/build.sh

docker image ls diva-doa
diva-doa     2.2.0     5f9dd8f9f0eb   14 hours ago   1.27GB
diva-doa     latest    5f9dd8f9f0eb   14 hours ago   1.27GB

This builds DOA and packs as container images. Now DOA is ready to use.

The next step executes a bundled run-doa.shwrapper script, which runs the DOA container. Specify the Git repository of the target database application. This example uses a Postgres database in the TradeApp application. You can use the -o option for the location of output files and an -i option for the name of the database initialization script:

cd /tmp/tackle-diva/doa
bash run-doa.sh -o /tmp/out -i start_up.sh \
[OK] successfully completed.

The /tmp/out/ directory and /tmp/out/trading-app, a directory with the target application name, are created. In this example, the application name is trading-app, which is the GitHub repository name. Generated artifacts (the YAML files) are also generated under the application-name directory:

ls -FR /tmp/out/trading-app/
cm-init-db.yaml  cm-sqls.yaml  create.sh*  delete.sh*  job-init.yaml  postgres.yaml  test//tmp/out/trading-app/test:

The prefix of each YAML file denotes the kind of resource that the file defines. For instance, each cm-*.yamlfile defines a ConfigMap, and job-init.yamldefines a Job resource. At this point, secret-db.yaml is not created, and DOA uses credentials that the Postgres operator automatically generates.

Now you have the resource definitions required to deploy a PostgreSQL cluster on a Kubernetes instance. You can deploy them using the utility script create.sh. Alternatively, you can use the kubectl createcommand:

cd /tmp/out/trading-app
bash create.sh  # or simply “kubectl apply -f .”configmap/trading-app-cm-init-db created
configmap/trading-app-cm-sqls created
job.batch/trading-app-init created
postgresql.acid.zalan.do/diva-trading-app-db created

The Kubernetes resources are created, including postgresql (a resource of the database cluster created by the Postgres operator), servicerspodjobcmsecretpv, and pvc. For example, you can see four database pods named trading-app-*, because the number of database instances is defined as four in postgres.yaml.

$ kubectl get all,postgresql,cm,secret,pv,pvc
NAME                                        READY   STATUS      RESTARTS   AGE

pod/trading-app-db-0 1/1     Running     0          7m11s
pod/trading-app-db-1 1/1     Running     0          5m
pod/trading-app-db-2 1/1     Running     0          4m14s
pod/trading-app-db-3 1/1     Running     0          4mNAME                                      TEAM          VERSION   PODS   VOLUME   CPU-REQUEST   MEMORY-REQUEST   AGE   STATUS
postgresql.acid.zalan.do/trading-app-db   trading-app   13 4      1Gi                                     15m   RunningNAME                            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
service/trading-app-db          ClusterIP    <none> 5432/TCP   15m
service/trading-app-db-repl     ClusterIP   <none> 5432/TCP   15mNAME                         COMPLETIONS   DURATION   AGE
job.batch/trading-app-init   1/1           2m39s      15m

Note that the Postgres operator comes with a user interface (UI). You can find the created cluster on the UI. You need to export the endpoint URL to open the UI on a browser. If you use minikube, do as follows:

$ minikube service postgres-operator-ui

Then a browser window automatically opens that shows the UI.

Screenshot of the UI showing the Cluster YAML definition on the left with the Cluster UID underneath it. On the right of the screen a header reads "Checking status of cluster," and items in green under that heading show successful creation of manifests and other elements

(Yasuharu Katsuno and Shin Saito, CC BY-SA 4.0)

Now you can get access to the database instances using a test pod. DOA also generated a pod definition for testing.

$ kubectl apply -f /tmp/out/trading-app/test/pod-test.yaml # creates a test Pod
pod/trading-app-test created
$ kubectl exec trading-app-test -it -- bash # login to the pod

The database hostname and the credential to access the DB are injected into the pod, so you can access the database using them. Execute the psql metacommand to show all tables and views (in a database):

# printenv DB_HOST; printenv PGPASSWORD
(values of the variable are shown)# psql -h ${DB_HOST} -U postgres -d jrvstrading -c '\dt'
             List of relations
 Schema |      Name      | Type  |  Owner  
 public | account        | table | postgres
 public | quote          | table | postgres
 public | security_order | table | postgres
 public | trader         | table | postgres
(4 rows)# psql -h ${DB_HOST} -U postgres -d jrvstrading -c '\dv'
                List of relations
 Schema |         Name          | Type |  Owner  
 public | pg_stat_kcache        | view | postgres
 public | pg_stat_kcache_detail | view | postgres
 public | pg_stat_statements    | view | postgres
 public | position              | view | postgres
(4 rows)

After the test is done, log out from the pod and remove the test pod:

# exit
$ kubectl delete -f /tmp/out/trading-app/test/pod-test.yaml

Finally, delete the created cluster using a script:

$ bash delete.sh