Cloud Computing and Cloud-native computing are two very different things. Here’s how
Difference between Cloud-native & Cloud Computing
Cloud Computing is the delivery of infrastructure (hardware/servers), storage, databases, and all kinds of application services via the internet. Frequently these are delivered by a cloud services platform like Amazon Web Services, Google Cloud, or Microsoft Azure. It has metered pricing so you pay only for the resources you consume.
Cloud-native computing is the architecture to combine all of the above cloud-based components in a way that is optimized for the cloud environment. It’s not about the servers, but the services.
So this is the basic difference between both. Now we can start understanding Cloud-native computing.
By definition Cloud-native computing is,
“An approach that builds software application as micro-services and runs them on a containerized and dynamically orchestrated platform to utilize the advantage of the cloud computing model.”
Cloud-native computing is about how applications are created and deployed on public, private, or hybrid cloud and then delivered to the users.
Cloud-native application development typically includes these steps…
- Agile Methodology
- Cloud Computing Platforms
- Containerize Application
- Orchestration System
- Continuous Delivery
Also Read: What is Cloud Computing?
The word DevOps consists of two words Developer and Operations. There are two teams Developer team and the Operation team.
In general, both teams perform different tasks for example
- Developer Team codes the application.
- Operation Team when the project is in executable form deploys the project/application on the systems.
Let’s start understanding DevOps. As u can see in the diagram above some tasks have encircled the word (dev)developer. While others have encircled the word (ops) or operation team.
We shall start with the developer’s task which are
The most initial part of any task is planing as for developer the planing includes
- Which language should be used.
- Prioritizing the tasks to be performed.
- how much time should be taken by each module.
- what and how many features should be there.
So the next thing after planning is to start coding.
- to structure the task
- perform some functionality
- writing some lines of code
Build means the module that you develop into an executable and deployable form.
- making it runnable for a test
- making it runnable for users
Testing the module/function by deploying it on the systems. Checking whether there is any kind of error in it or not.
It’s a phase where we handover the built code to the operation team, which can then be deployed on systems.
Now we shall start with the Operation team’s task which are
what is deployment?
It’s running the code or the developed application on the servers so that the users can access it.
Operating the application is the continuous process/phase to solve any issues occurring in the system.
Monitoring is analyzing if the system has any problem that can be rectified or not.
And then again planning for a new feature, coding it and so on the cycle starts again.
Agile development is the method used by cloud-native computing to develop applications today.
But before discussing Agile, I will discuss what was used before the Agile method.
Before the Agile method Waterfall method/technique was used. Where all the bulky work was done in the ‘Development’ phase. It was not deployed before all the features were completed.
The problem with this method was that developer will spend a certain time. Let say six months to two years to develop all the features. Then it was deployed because according to the method application must have certain main features. when the app was delivered to the users they would not pay attention to the features. which according to the company were important. This results in wastage of resources, money, and the time of the company. It is also difficult to apply changes according to the user’s need.
Agile methodology is described as an iterative or incremental approach. Agile developer visualizes the software as a combination of complex parts that interacts with each other rather than a large block of structure. Actually, in the waterfall method, the development team will get only a single chance to get each phase like (design, development, testing) of a project. Whereas in agile methodology these phases are continually revisited periodically to identify/understand the project’s progress and directions.
The ‘Inspect and Adapt’ approach from Agile methodology, greatly reduces development costs and time to market the product because here teams can develop software while gathering requirement changes.
The stakeholders can provide feedback to the development team to improve the quality of the product.
Agile development does save a lot of resources that could have been spent on something not needed anymore.
Cloud-Native applications are built as a system of micro-services.
The general idea of this architectural style is to implement a system of multiple, relatively small applications. These are called Micro-services. They work together to provide the overall functionality of the system.
Each Microservice realizes
- Exactly one functionality.
- Has a well-defined boundary and API(Application Programming Interface-used for communication)
- Gets developed and Operated by a relatively small team.
A microservice architectural style is an approach to developing a single application as a suite of small services.
Each runs in its process and communicates with a lightweight mechanism, Often and HTTP resource API.
Microservices do have some distinct advantages:
- Microservices architecture is organized.
- Each Microservice has a very specific job and is not concerned with the jobs of other components.
- Decoupled services are also easier to change, update, and reconfigure to serve the purposed of different apps.
- They also allow for fast, independent delivery of individual parts with a larger integrated system.
- Microservices also have performance advantages, Under the right circumstances, and that depends on how it’s organized.
- It’s possible to isolate services and scale them independently of the rest of the app.
Benefits of Microservices
- A lot easier to implement and understand a smaller application that provides one functionality, instead of building a large application that does everything.
- It speeds up development and makes it a lot easier to adapt the service to changed or new requirements.
- You need to worry a lot less about the unexpected side effects of a seemingly small change, and you can focus on the development task at hand.
- It also all us to Scale more efficiently.
- In a cloud environment, you only pay for the service you use.
Challenges using Microservices:
There is a saying ‘There is no such thing as a free lunch’.
Although microservices remove some complexity from the services themselves and provide better scalability, you are now building a distributed system. That adds a lot more complexity to the system level.
To make sure that the dependent services find each other and communicate efficiently it’s a challenging task when the number of microservices is many.
You also need to handle slow or unavailable services so that they don’t affect the complete system.
The distributed nature of your system also makes it a lot harder to monitor and manage your system in production.
You now need to monitor a system of microservices and for each service, there might several instances that run in parallel.
Cloud Computing Platforms
Cloud Computing is the ON demand availability of computer system resources. Especially data storage and computing power, without direct active management by the user.
The term is generally used to describe data centers commercially available to many users over the internet, they are Cloud Computing Platforms.
Large clouds, predominant today, often have functions distributed over multiple locations from central servers. If the connection to the user is relatively close, it may be designated as edge servers.
An edge server also called Content Delivery Network or Content Distribution Network(CDN) is a geographically distributed network of proxy servers and their data centers. The goal is to provide high availability and high performance by distributing the service spatially relative to the end-users.
Cloud’s limitations are
- A single organization(Enterprise Clouds).
- Be available to many organizations (Public Clouds).
- A combination of both(Hybrid Clouds).
The largest public cloud is Amazon Web Services(AWS). There are many others like Google Cloud or Microsoft Azure, Alibaba Cloud, IBM cloud.
Advocates of public and hybrid clouds note that cloud computing allows companies to avoid or minimize up-front IT infrastructure costs.
The experts also claim that cloud computing allows enterprises to get their applications up and running faster. Which also has improved manageability and less maintenance. It also enables IT, teams, to rapidly adjust their resources. To meet the fluctuating and unpredictable demand.
Cloud Providers mostly use a ‘Pay as you go’ model.
A container is a runtime instance of an image.
An image is an executable package. It includes everything you need to run an application
- The code
- A runtime
- Environment variables
- Configuration Files
Containerization is the usage of images for any application. Docker allows us to containerize applications.
Containerization is increasingly popular because containers are
- Flexible: Even the most complex application can be containerized.
- Lightweight: Container leverage and share the host kernel.
- Interchangeable: You can deploy updates and upgrades on the fly.
- Portable: You can build locally, deploy to the cloud, and run anywhere.
- Scalable: You can increase and automatically distribute containers replicas.
- Stackable: You can stack services vertically and on the fly.
Deploying your application with all the dependencies into the container is the first step. Making an app containerized solves the deployment problems you had previously. Now the new challenges are
- Scaling an app based on the current load of your system isn’t that easy.
- you need to monitor your system.
- Trigger the startup or shut down of a container.
- Make sure that all the required configuration parameters are in place.
- Balance the load between the active application instances.
- Share authentication secrets between your containers.
- To do all this manually requires a lot of effort and is too slow to react to unexpected changes in the system loads.
- you need to have the right tools in place that automatically do all of this.
This is the reason to build different orchestration solutions. Kubernetes is the most popular.
Continuous Integration / Development
This method helps us to deliver apps to customers frequently. Because we have introduced automation into the stages of app development. Now the development and operation team does not have to integrate new code that can cause problems.
CI introduces ongoing automation and continuous monitoring for the lifecycle of apps. From integration and testing to the delivery and deployment phase.
All this connected practice is called ‘CI pipelines’.
CI/CD also uses Jenkins.
I hope you find this article helpful. If you have any questions use the comment section and feel free to leave some suggestions too.