Azure Container Service
The Azure Container Service (ACS) is a cloud-based container deployment and management service that supports popular open-source tools and technologies for container and container orchestration. ACS allows you to run containers at scale in production and manages the underlying infrastructure for you by configuring the appropriate VMs and clusters for you. ACS is orchestrator-agnostic and allows you to use the container orchestration solution that best suits your needs. Learn how to use ACS to scale and orchestrate applications using DC/OS, Docker Swarm, or Kubernetes.
- Operation Engineers
- Anyone interested in managing containers at scale
- Viewers should have a basic understanding of containers.
- Some familiarity with the Azure platform will also be helpful but is not required.
- Demonstrate how to use ACS to create virtual machine hosts and clusters for container orchestration
- Understand how to choose an open-source orchestration solution for ACS
- Understand how to run containers in production on Azure using ACS
- Demonstrate the ability to scale and orchestrate containers with DC/OS, Docker Swarm, and Kubernetes
This Course Includes
- 60 minutes of high-definition video
- Live demonstration on key course concepts
What You'll Learn
- Overview of Azure Container Service: An overview of containers and the advantages of using them.
- Orchestrators: A summary of what orchestrators are and a description of the most popular orchestrators in use
- Open Source Cloud-First Container Management at Scale: This lesson discusses the purpose of ACS, and how the service is activated.
- Deployment Scenarios: A brief explanation of different orchestrator scenarios.
- Deploy Kubernetes and Security: A live demo on how to deploy K8S.
- Deploy Kubernetes from the Portal: A live demo on how to create a security key and a K8S cluster.
- Deploy Kubernetes from the CLI: A live demo on the Command Line Interface.
- Orchestrator Overview – Kubernetes: A lesson on managing containers. First up..Kubernetes.
- Orchestrator Overview – DC/OS: In this lesson, we discuss deploying containers to the Data Center Operating System.
- Orchestrator Overview – Swarm: In this last lesson we'll look at how ACS deploys Swarm.
- Summary and Conclusion: A wrap-up and summary of what we’ve learned in this course.
Next I'll show you to do the same thing using the Azure Command Line Interface. Now let's see how to create the same cluster using the Azure Command Line. Once again, I've invoked the Cloud Shell because I can run that from my browser and it doesn't require any type of installation.
What we're going to do is set a few variables in the shell. First, we'll set a name for a resource group, we'll set a name for a location, and then we're going to use the Azure Command Line, command group create, this will create our resource group for us. So we'll use the variable there, and the location variable. Let that run.
Now that the creation has succeeded, we'll create a DNS prefix, remember this is what needs to be unique to access externally, so I'm gonna call it Cloud Academy Azure Container Service Kubes, for Kubernetes. Gonna give it a cluster name of my-k8s-cluster, and then I'm gonna run this command, acs create --orchestrator-type=kubernetes, resource group, and we'll use the resource group variable we created. Name will equal the cluster name, DNS prefix, we'll tell it to generate its own SSH keys, and let that spin.
After several minutes, it's returned back and let me know that the provisioning state has succeeded, so we should be able to take a look, up here. Refresh our resource groups, here's the Cloud Academy ACS, and if we go inside that, we should see the same resources that we saw when we created it through the portal UI. Now that we have it created, let's do a couple more steps just to make sure the cluster's running correctly.
The Azure Cloud Shell comes pre-installed with the Kubernetes Command Line Interface, or the Kube Controller. So what we need to do now is map our credentials to that command line interface, so it knows which cluster it's interacting with. So what we'll do is use the Azure Command Line Interface, the Azure Container Service and pass it through the Kubernetes orchestrator, a command called, get-credentials.
This will pull the down the appropriate credentials based on the resource group that we created, and the cluster that we created. So that will go out and fetch those credentials and then we should be able to use the Kubernetes controller to get nodes and confirm that those agents are running. And as you can see, we have one master and three child agents running on this cluster.
Jeremy Likness is an experienced entrepreneur who has worked with companies to catalyze growth and leverage leading edge development technology to streamline business processes and support innovation for two decades. Jeremy is a prolific author with four published books and hundreds of articles focused on helping developers be their best. Jeremy speaks at conferences around the country and covers topics ranging from technologies like Docker, Node.js and .NET Core to processes and methodologies like Agile and DevOps. Jeremy lives near Atlanta with his wife of 19 years and teen-aged daughter. His hobbies including hiking, climbing mountains, shooting 9-ball, and regularly attending CrossFit classes while maintaining a vegan diet.