In this article, we will look at the detailed steps to install Alibaba Cloud Container Service for Kubernetes (ACK) cluster. We will cover the Azure DevOps release pipeline and configure service connection to the Kubernetes cluster using temporary kubeconfig. After that, we will expose the application in Alibaba Cloud Kubernetes using Ingress.
High-level steps:
This is an article from DZone’s 2021 Kubernetes and the Enterprise Trend Report.
For more:
In the modern technology landscape, Kubernetes is a widely adopted platform that enables organizations to deploy and manage applications at scale. The container orchestration platform simplifies infrastructure provisioning for microservice-based applications, which empowers efficient workload management through modularity. Kubernetes supports various deployment resources to help implement CI/CD pipelines using updates and versioning. While Kubernetes offers rolling updates as the default deployment strategy, several use cases require a non-conventional approach to deploying or updating cluster services.
This is an article from DZone’s 2021 Kubernetes and the Enterprise Trend Report.
For more:
As more organizations have begun to embrace cloud-native technologies, Kubernetes adoption has become the industry standard for container orchestration. This shift toward Kubernetes has largely automated and simplified the deployment, scaling, and management of containerized applications, providing numerous benefits over legacy management protocols for traditional monolithic systems. However, securely managing Kubernetes at scale comes with a unique set of challenges, including hardening the cluster, securing the supply chain, and detecting threats at runtime.
This is the first piece in a series on developing XR applications and experiences using Oracle. Specifically, I will show applications running with the following:
Throughout the blog, I will reference a corresponding workshop video found at https://youtu.be/MBaQ8ohI80E.
Our profession evolves every year, whether through the introduction of a new tool, a new cloud service, or a new working method. This constant evolution requires the establishment of a learning culture to continuously share experiences and ideas, thus encouraging everyone to gain new knowledge each year.
Obviously, this demands a portion of our working time and an online library of training resources maintained by entities with authority in the domain. These entities are responsible for updating the content to allow us to continuously improve our skills, sometimes to advance in our career in order to aim for an internal or external evolution. Therefore, relying on trusted education partners is important to ensure the highest-quality learning content.
There has been a couple of years since the announcement of the removal of Apache Zookeeper as a dependency to manage Apache Kafka metadata. Since version 2.8, we now can run a Kafka cluster without Zookeeper. This article will go over three easy ways to get started with a single node cluster using containers.
Apache Kafka implements independent control and data planes for its clusters. The control plane manages the cluster, keeps track of what brokers are alive, and takes action when the set changes. Meanwhile, the data plane consists of the features required to handle producers and consumers and their records. In the previous iterations, Zookeeper was the cluster component that held most of the implementation of the control plane.
Welcome to the third blog post in our “Kubeflow Fundamentals” series specifically designed for folks brand new to the Kubelfow project. The aim of the series is to walk you through a detailed introduction of Kubeflow, a deep-dive into the various components, and how they all come together to deliver a complete MLOps platform.
If you missed the previous installments in the “Kubeflow Fundamentals” series, you can find them here:
I was lucky. I already had extensive knowledge of Docker before starting the certification for Kubernetes developer (CKAD), and I have an employer (Ordina) that gives me the space and time to invest in myself.
So I claimed a week of preparation and did the whole Kubernetes for Developers (LFD259) course. To follow this course, you have to prepare a practice environment, and you are given instructions on how to do that on AWS or Google Cloud (which can result in extra costs). It is also very possible to create a cluster on your local machine. To make my life easier (and cheaper) I opted for the last option and created a vagrant set up with instructions for it here.
With the ecosystem being extremely saturated with a diversity of tools such as monitoring, observability, tracing, logging, and much more, it’s hard to truly understand how troubleshooting differs from these typical tools.
Today, when incidents occur, it is becoming increasingly complex to get a grasp on where to even get started with understanding what you’re up against, and then ultimately fixing the immediate issue, and then remediating the root cause.
To teach myself Kubernetes in general and controllers in particular, I previously developed one in Java. This week, I decided to do the same in Rust by following the same steps I did.
The guiding principle is creating a Kubernetes controller that watches pods’ lifecycle and injects a sidecar into them. When Kubernetes schedules the pod, the controller schedules the sidecar; when it deletes the former, it deletes the latter as well.
