Tag: cloud native application development

Posted on by — Leave a comment

Learning Infrastructure as Code: What You Need to Know for Cloud Native Engineering

As a new engineer, understanding Infrastructure as Code (IAC) is important for several reasons.

First, IAC is a key component of cloud native application development. It is the practice of managing and provisioning infrastructure using code, rather than manual configuration. By understanding how IAC works, you can build, deploy, and manage cloud-native applications more effectively.

Second, IAC allows for greater consistency and reproducibility. By using code to manage and provision infrastructure, it ensures the same configuration is used across different environments and that the infrastructure can be easily recreated if necessary. This makes it easier to handle increasing demand for computing power and storage.

Third, IAC promotes better collaboration and a DevOps culture. By using code to manage and provision infrastructure, it becomes easier for different teams and developers to work together on the same application.

Fourth, IAC allows for better tracking and version control of infrastructure changes. By keeping the infrastructure definition in code, it allows for tracking changes in the same way as code changes and reverting to previous versions if necessary.

In summary, understanding IAC is important because it is a key component of cloud native application development, allows for greater consistency and reproducibility, promotes better collaboration and DevOps culture, and allows for better tracking and version control of infrastructure changes. It is a powerful tool for building and deploying applications in a cloud environment and is essential for any engineer working in the field today.

Learning Materials

Here’s a list to get you started learning about Infrastructure as code (IAC). Note that some of these links may not be free and may require a subscription or payment. I receive no affiliate payments for these links.

Beginner:

Intermediate:

Advanced:

Videos to Watch

Cloud Native Summit – Five ways to manage your Infrastructure as Code at Scale / Ryan Cartwright

This document provides an overview of the challenges of cloud native engineering and the solutions available, such as remote state management, avoiding manual state changes, using CI tools, and implementing a reliable SAS offering. It also covers the features and security essentials that must be included in a terraform CI platform.

Possible Learning Path

Hands-on experience: Start by setting up a simple Kubernetes cluster and experimenting with different IAC tools such as Terraform, Ansible, and Helm. This can be done by following tutorials and guides and deploying these tools on a cloud platform like AWS, Azure, or GCP.

Theoretical learning: Once you have a basic understanding of IAC, you can begin to explore the underlying concepts and technologies such as configuration management, version control, and automation. This can be done through online resources such as tutorials, courses, and documentation provided by IAC tools, as well as books and blogs on the topic.

Understanding the principles and best practices: IAC is an important aspect of modern infrastructure management, so it’s important to understand the key principles and best practices of IAC, such as versioning, testing, and rollback.

Joining a community: Joining a community of IAC enthusiasts will help you connect with other people who are learning and working with IAC for Kubernetes. This can be done through online forums, meetups, and social media groups.

Practice, practice, practice: As with any new technology, the best way to learn is by doing. The more you practice deploying and using IAC tools in a Kubernetes cluster, the more comfortable and proficient you will become with the technology.

A Note from the Architect

Infrastructure as Code (IaC) is one of the most exciting developments in cloud deployments. It is a way of describing and provisioning infrastructure using code, instead of manual configuration. This makes it easier to manage and maintain over time, as well as enabling faster scaling, testing, and deploying of cloud native solutions.

Version control is essential for modern operations teams, as it allows them to track changes to the infrastructure over time and roll back to a previous version if something goes wrong. Developers should also learn it, as it allows them to collaborate more easily with operations teams and to understand the infrastructure that their code is running on.

IaC helps to ensure quality by allowing for automated provisioning and configuration of infrastructure. It also helps to ensure security, as it enables more controlled and automated access to infrastructure, making it easier to identify and isolate any malicious activity.

In conclusion, IaC is a great way to deploy cloud native solutions, as it makes it easier to manage and maintain over time. Version control is essential for modern operations teams, and developers should also learn it. Writing IaC helps to ensure quality and can help with security by allowing for more controlled and automated access to infrastructure.

Connect with Shawn
Connect with Shawn

Connect with me on LinkedIn. It’s where I’m most active, and it’s the easiest way to connect with me.

Shawn’s LinkedIn
Posted on by — Leave a comment

An Introduction to Continuous Integration and Continuous Deployment (CI/CD): Understanding the Benefits, Learning Materials, Videos to Watch and a Possible Learning Path

As a new engineer, understanding the concept of continuous integration and continuous deployment (CI/CD) is important for several reasons.

First, CI/CD is a key component of cloud native application development. It is the process of automatically building, testing, and deploying code changes as soon as they are committed to the code repository. By understanding how CI/CD works, you will be able to build, deploy, and manage cloud-native applications more effectively.

Second, CI/CD allows for faster development and deployment. By automating the build, test, and deployment process, it enables developers to make changes to the code and have them deployed to production faster. This facilitates faster innovation and time-to-market for new features.

Third, CI/CD promotes better collaboration and DevOps culture. By automating the process of building, testing, and deploying code changes, it becomes easier for different teams and developers to work together on the same application.

Fourth, CI/CD allows for better quality and reliability of the software. By automating the testing process, it ensures that code changes are tested as soon as they are made, which helps to catch any bugs or errors early in the development cycle.

In summary, as a new engineer, understanding the concept of CI/CD is important because it is a key component of cloud native application development, allows for faster development and deployment, promotes better collaboration and DevOps culture, and allows for better quality and reliability of the software. It is a powerful tool for building and deploying applications in a cloud environment and is essential for any engineer working in the field today.

Learning Materials

Here’s a list to get you started learning about CI/CD. Note that some of these links may not be free and may require a subscription or payment. I receive no affiliate payments for these links.

Beginner:

Intermediate:

Advanced:

Videos to Watch

The Foundations of Continuous Delivery

Continuous Delivery is a revolutionary approach to software development that focuses on efficient feedback, strong engineering discipline, reducing the amount of work, and cycle time reduction. Automation is essential to reducing cycle time and the deployment pipeline is used to prove that changes are fit for production.

Possible Learning Path

Hands-on experience: Start by setting up a simple Kubernetes cluster and experimenting with different CI/CD tools such as Jenkins, Travis CI, and GitLab CI/CD. This can be done by following tutorials and guides and deploying these tools on a cloud platform like AWS, Azure, or GCP.

Theoretical learning: Once you have a basic understanding of CI/CD, you can begin to explore the underlying concepts and technologies such as pipeline management, version control, and testing. This can be done through online resources such as tutorials, courses, and documentation provided by CI/CD tools, as well as books and blogs on the topic.

Understanding the principles and best practices: CI/CD is an important aspect of modern software development, so it’s important to understand the key principles and best practices of CI/CD such as automation, testing, and deployment.

Joining a community: Joining a community of CI/CD enthusiasts will help you connect with other people who are learning and working with CI/CD for Kubernetes. This can be done through online forums, meetups, and social media groups.

Practice, practice, practice: As with any new technology, the best way to learn is by doing. The more you practice deploying and using CI/CD tools in a Kubernetes cluster, the more comfortable and proficient you will become with the technology.

A Note from the Architect

I’m about to tell you how I used to publish my websites way back in the day. You see, back then, many of us actually kept a really powerful server under our desks. I had such a server. This server had a network card with two different IP addresses bound to it. One was a Public IP address. Yes, I had a public IP address bound directly onto the network card of the server sitting under my desk. I also had a private IP address so that I could share the website’s folder on the network for the whole company.

Ok, stop laughing, you’re making me feel bad. I haven’t even mentioned the fact that I edited my Active Server Pages directly from that folder. That’s right, changes went directly from development to the internet with no steps in between. I had lots of files that were named things like, “about-us.asp.old, about-us.asp.older, about-us.asp.donotuse.’

Well, luckily those days are behind us. Today we use CICD (Continuous Integration and Continuous Deployment).

CICD is a software development practice that involves automatically building, testing, and deploying code changes. The basic idea behind CICD is to catch and fix errors as early as possible, which helps to prevent bugs and other issues from making it into production. This is accomplished by integrating the code changes into a central repository and then running a series of automated tests and builds.

It’s more popular now because it helps to improve software quality, increase collaboration among developers, and reduce time to market for new features. It also helps to ensure that software is always in a releasable state, which makes it easier to roll out new features and bug fixes.

One of the key enablers of CICD is version control. Version control is a necessity for modern development because it allows developers to track changes to the codebase over time, collaborate with other developers, and roll back to a previous version if something goes wrong. There’s no longer a need to append extra extensions onto files you might want to keep as backup.

Pipelines help to ensure quality by automating the process of building, testing, and deploying code changes. This makes it easier to catch and fix errors early in the development process, which helps to prevent bugs and other issues from making it into production. It can also help with security by establishing a software supply chain. When code changes are automatically built, tested and deployed, it’s easier to track, identify and isolate any malicious code that may have been introduced in the codebase.

Basically, CICD is a software development practice that involves automatically building, testing, and deploying code changes. It helps to improve software quality, increase collaboration among developers, and reduce time to market for new features. Version control is a necessity for modern development, and pipelines help to ensure quality and can help with security by establishing a software supply chain.

Connect with Shawn
Connect with Shawn

Connect with me on LinkedIn. It’s where I’m most active, and it’s the easiest way to connect with me.

Shawn’s LinkedIn
Posted on by — Leave a comment

What is Load Balancing, and How Can it Help Your Cloud-Native Applications?

As a new engineer, understanding the concept of load balancing is important for several reasons.

First, it is a key component of cloud native application development. It is the process of distributing incoming network traffic across multiple servers to ensure that no single server is overwhelmed. By understanding how it works, you will be able to build, deploy, and manage cloud-native applications more effectively.

Second, load balancing allows for greater scalability and availability. By distributing traffic across multiple servers, it ensures that the system can handle a large number of requests and can continue to function even if one server goes down. This makes it easy to handle the increasing demand for more computing power and storage.

Third, it facilitates better collaboration and DevOps culture. By making it easy to distribute traffic across multiple servers, it becomes easier for different teams and developers to work together on the same application.

Fourth, it enhances security, by distributing the traffic across multiple servers, it makes it harder for attackers to target a single point of failure.

In summary, as a new engineer, understanding the concept of load balancing is important because it is a key component of cloud native application development, allows for greater scalability and availability, better collaboration and DevOps culture, and better security. It is a powerful tool for building and deploying applications in a cloud environment and is essential for any engineer working in the field today.

Learning Materials

Here’s a list to get you started learning about load balancing. Note that some of these links may not be free and may require a subscription or payment. I receive no affiliate payments for these links.

Beginner:

Intermediate:

Advanced:

Videos to Watch

How load balancing and service discovery works in Kubernetes

Kubernetes provides a range of features to enable applications to communicate with each other, including service discovery, load balancing, DNS, and port management. These features are enabled through the use of namespaces, labels, services, and Linux networking features such as bridges and IP tables.

A Possible Learning Path

Hands-on experience: Start by setting up a simple Kubernetes cluster and experimenting with different load balancing mechanisms such as Kubernetes Services, Ingress, and External Load Balancers. This can be done by following tutorials and guides and deploying these services on a cloud platform like AWS, Azure, or GCP.

Theoretical learning: Once you have a basic understanding of load balancing, you can begin to explore the underlying concepts and technologies such as Kubernetes Services, Ingress, and External Load Balancers. This can be done through online resources such as tutorials, courses, and documentation provided by Kubernetes, as well as books and blogs on the topic.

Understanding the principles and best practices: Load balancing is an important aspect of a microservices architecture, so it’s important to understand the key principles and best practices of load balancing such as traffic distribution, service availability, and fault tolerance.

Joining a community: Joining a community of Kubernetes enthusiasts will help you connect with other people who are learning and working with load balancing for Kubernetes. This can be done through online forums, meetups, and social media groups.

Practice, practice, practice: As with any new technology, the best way to learn is by doing. The more you practice deploying and using load balancing mechanisms in a Kubernetes cluster, the more comfortable and proficient you will become with the technology.

A Note from the Architect

A load balancer is like an air traffic controller for your network. It ensures that traffic is evenly distributed across all servers, so that no single server becomes overwhelmed and crashes. This is especially important when there is a lot of incoming traffic or a large number of users accessing the application.

In traditional networks, load balancers are typically dedicated hardware devices that sit in front of the servers and manage the traffic. However, in cloud-native networks, load balancers are usually software-based and run as part of the infrastructure. This is where Kubernetes comes into play.

Kubernetes has a built-in load balancer that can be easily configured with the Kubernetes resources. It automatically distributes traffic to the services running in the cluster. This is a great advantage, as it allows for more flexibility, scalability, availability, and the ability to handle failover automatically.

Another benefit of using a load balancer in a cloud-native network is that it makes it possible to expose services to the outside world. This means that services can be accessed from anywhere, which is especially useful if you want to access them from the internet.

Using a load balancer in a cloud-native network has many advantages, such as increased availability, scalability, and flexibility, as well as the ability to handle failover automatically. Plus, it’s like having a superhero that ensures traffic is evenly distributed and users are happy.

Connect with Shawn
Connect with Shawn

Connect with me on LinkedIn. It’s where I’m most active, and it’s the easiest way to connect with me.

Shawn’s LinkedIn
Posted on by — Leave a comment

Understanding Microservices Architecture: Key Concepts, Learning Resources & More

As a new engineer, understanding the concept of microservices architecture is important for several reasons.

First, it is a key component of cloud native application development. It allows for faster development, easier scaling, and more flexible deployment options. By understanding how microservices work, you will be able to build, deploy, and manage cloud-native applications more effectively.

Second, microservices architecture promotes modularity, which allows for greater flexibility, scalability, and maintainability of the system. Each microservice can be developed, deployed, and scaled independently, making it easier to handle increasing demand.

Third, microservices architecture facilitates better collaboration and DevOps culture. By breaking down the application into smaller, independent units, different teams and developers can work together on the same application.

Fourth, microservices architecture allows for greater resilience. By isolating the failure in one service, it will not impact the entire system.

In summary, understanding the concept of microservices architecture is essential for any engineer working in the field today. It is a powerful tool for building and deploying applications in a cloud environment and provides benefits such as faster development, easier scaling, more flexible deployment options, greater flexibility, scalability, and maintainability, better collaboration and DevOps culture, and greater resilience.

Learning Materials

Here’s a list to get you started learning about Microservices architecture. Note that some of these links may not be free and may require a subscription or payment. I receive no affiliate payments for these links.

Beginner:

Intermediate:

Advanced:

Videos to Watch

Microservices explained – the What, Why and How?

In this video, the Nana explains the concept of microservices architecture and its advantages over monolith architecture. He also discusses best practices for microservices communication, such as using API calls, message brokers, and service meshes. Finally, he mentions the importance of a CI/CD pipeline for deploying microservices.

Possible Learning Path

Hands-on experience: Start by experimenting with building simple microservices using technologies such as Node.js, Spring Boot, or Flask. This can be done by following tutorials and guides and deploying these services on a cloud platform like AWS, Azure, or GCP.

Theoretical learning: Once you have a basic understanding of microservices, you can begin to explore the underlying concepts and technologies. This can be done through online resources such as tutorials, courses, and documentation provided by microservices architecture, as well as books and blogs on the topic.

Understanding the principles and best practices: Microservices architecture is not just about technology; it’s also about principles and best practices. It’s important to understand the key principles and best practices of microservices, such as loose coupling, autonomy, and scalability.

Joining a community: Joining a community of microservices enthusiasts will help you connect with other people who are learning and working with microservices architecture. This can be done through online forums, meetups, and social media groups.

Practice, practice, practice: As with any new technology, the best way to learn is by doing. The more you practice building and deploying microservices, the more comfortable and proficient you will become with the architecture.

A Note from the Architect

I’m not in the camp that thinks monolithic architecture is necessarily bad. However, I believe that, in the long run, microservices have a better chance of success. Are microservices more work? Yes, there is an overhead associated with them, but I think it’s worth it for the added flexibility.

To explain the difference between microservices and traditional monolithic architectures, a monolithic architecture is when all the different parts of an application, such as the user interface, the database, and the backend, are bundled together in one package. This can work well for small projects, but as the project grows and becomes more complex, it can become harder to manage and maintain.

On the other hand, microservice architecture breaks the application down into smaller, individual services. Each service is responsible for a specific task, such as user authentication or payment processing.

The benefits of microservices include the ability to make changes to one service without affecting the others, as well as more flexibility and scalability, since each service can be deployed and scaled independently.

For example, here’s some code in Python that demonstrates a microservice:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

This code is a simple web service that listens for a request to the root URL and returns the string “Hello, World!”.

That doesn’t do much, but it does show how you can quickly create a service. A series of these services working together could create a more robust solution. I won’t dive into the Actor Pattern, but it’s probably the ideal approach to microservices.

Keep in mind, an organization would select microservices over other architectures because they are more flexible, scalable, and easier to maintain as the project grows. Plus, it’s way cooler to say you’re working with microservices than a monolithic architecture. Trust me, it’s like being in a secret club of developers who know how to handle complexity in the best way possible.

Connect with Shawn
Connect with Shawn

Connect with me on LinkedIn. It’s where I’m most active, and it’s the easiest way to connect with me.

Shawn’s LinkedIn
Posted on by — Leave a comment

Understanding Containerization: A Guide for New Engineers

As a new engineer, understanding the concept of containerization is important for several reasons.

First, containerization is a key component of cloud native application development. Containers are a lightweight and portable way to package software, making it easy to run and manage applications on cloud infrastructure. By understanding how containers work, you will be able to build, deploy, and manage cloud-native applications more effectively.

Second, containerization allows for greater consistency and portability across different environments. With containers, you can package an application and its dependencies together, ensuring that it will run the same way regardless of where it is deployed. This eliminates the “works on my machine” problem and makes it easier to move applications between different environments.

Third, containerization allows for greater scalability and resource efficiency. Containers use less resources than traditional virtual machines, and can be easily scaled up or down as needed. This makes it easier to handle the increasing demand for more computing power and storage.

Fourth, containerization also allows for better collaboration and DevOps culture, as containers can be easily shared and reused, making it easier for different teams and developers to work together on the same application.

In summary, as a new engineer, understanding the concept of containerization is important because it is a key component of cloud native application development, allows for greater consistency and portability across different environments, enables greater scalability and resource efficiency, and promotes collaboration and DevOps culture. It is a powerful tool for building and deploying applications in a cloud environment and is essential for any engineer working in the field today.

Learning Materials

Here’s a list to get you started learning about containerization. Note that some of these links may not be free and may require a subscription or payment. I receive no affiliate payments for these links.

Beginner:

Intermediate:

Advanced:

Videos to Watch

Kubernetes Crash Course for Absolute Beginners

Kubernetes is an open source container orchestration framework designed to manage applications made up of hundreds or thousands of containers across multiple environments. It offers features such as high availability, scalability, and disaster recovery, as well as a virtual network that enables communication between pods. This video provides an overview of the Kubernetes architecture and components, and a use case of a web application with a database to illustrate how it works.

Possible Learning Path

Hands-on experience: Start by installing Docker and Kubernetes on your local machine or in a virtual environment. This can be done by following the official documentation provided by Docker and Kubernetes. After that, you can follow tutorials and guides to build and deploy simple applications in containers using Docker and Kubernetes.

Theoretical learning: Once you have a basic understanding of Docker and Kubernetes, you can begin to explore the underlying concepts and technologies. This can be done through online resources such as tutorials, courses, and documentation provided by Docker and Kubernetes, as well as books and blogs on the topic.

Joining a community: Joining a community of Docker and Kubernetes enthusiasts will help you connect with other people who are learning and working with these technologies. This can be done through online forums, meetups, and social media groups.

Practice, practice, practice: As with any new technology, the best way to learn is by doing. The more you practice building and deploying containerized applications using Docker and Kubernetes, the more comfortable and proficient you will become with these technologies.

Specialize in a specific use case: Docker and Kubernetes can be used in a wide variety of scenarios and use cases, so it is beneficial to specialize in one or two that align with your business or career goals.

A Note from the Architect

I’m trying to think of the first time I worked with a Docker container. I believe it was almost four years ago, which in technology timeframes was forever. I was trying to decide if I wanted to use Angular or React to create components for a plugin framework running on SharePoint. It wasn’t the type of development I was used to doing at the time, but I knew the industry was heading away from Angular and more toward React. So, I installed Docker on my laptop, learned how to check out the images, and eventually started learning the basics of containers. I was hooked. Here was a great way to build apps, host them locally, and get the same experience locally that I could expect in production. No more, “It worked on my machine.”

In the last couple of years, I’ve used the remote connection capabilities of VS Code to run pretty much all of my development in containers. It gives me the freedom to try out different languages, frameworks, and libraries without ever needing to install those on my local operating system. I’m proud to say that I never get bugged for Java or .Net updates now. I just get the latest images and add a volume that connects to a local folder where I manage my Git repositories. It’s made my life as a developer much easier.

If you’re wondering, “What’s the big deal with containers? I just want to write code. Why do I need to use containers?” I’ll try to answer that question. Because we don’t just write code anymore. As developers and as operations engineers, we’re beginning to move into a phase where we are sharing the overall solution. This means that when I create something or have a hand in creating something, I have ownership over that thing. I’m responsible for it.

Now, you might work for an enterprise that’s still a bit behind the times. You may write code, and some other team might test that code, and then some other team might try to deploy that code. In that situation, you probably aren’t using containers or anything that looks like modern DevOps. And in that situation, the team between you and the customers who will derive value from your code is a bottleneck. If you rely on a QA team, they will find bugs, because that’s what they are incentivized to do. It’s their job to compare your code against some form of requirements and fail it if it doesn’t meet those requirements. Operations in this type of environment is incentivized to keep systems running smoothly, so they’ll look for any excuse to deny your code entry into production—that usually looks like a set of meetings designed to make sure you met all the criteria needed for something to go into production.

That is the old way of developing software. Let me tell you, if you’re working some place like that, get out. No. Seriously. Leave. Find a better job.

I believe this is the way software should be developed:

The Most Powerful Software Development Process Is The Easiest

In an ideal software development process, the only work done is understanding the problem, writing code to solve it, testing to confirm it is solved, and making progress in small steps to retain the ability to change the system when needed. The goal is to minimize work and maximize learning, allowing for changes to be made easily and with confidence.

Containers make this process easier. Your code remains modular, making it easier to version and manage libraries and dependencies. You can even build out the needed infrastructure for a container management system, such as Kubernetes, without involving operations in some cases.

As a developer and an architect, I have found that containers have improved the quality of my development life. They have allowed me to have more control over the solutions I deliver. I believe that if you start working regularly with containers, you will feel the same way too.

Connect with Shawn
Connect with Shawn

Connect with me on LinkedIn. It’s where I’m most active, and it’s the easiest way to connect with me.

Shawn’s LinkedIn