Tag: Kubernetes

Duration

14 hours (usually 2 days including breaks)

Requirements

• Experience with Kubernetes

Audience

• Developers
• System administrators
• DevOps engineers

Overview

This instructor-led, live training (online or onsite) is aimed at engineers wishing to run containerized applications using the CRI-O container runtime.

By the end of this training, participants will be able to:

• Install and configure the CRI-O container runtime.
• Pull images from a variety of OCI-compliant registries.
• Run, test and manage containerized applications using CRI-O.

Format of the Course

• Interactive lecture and discussion
• Lots of exercises and practice
• Hands-on implementation in a live-lab environment

Course Customization Options

• To request a customized training for this course, please contact us to arrange.
• To learn more about CRI-O, please visit: http://cri-o.io/.

Course Outline

Introduction

• CRI vs CRI-O vs OCID

Overview of CRI-O Features and Architecture

• Kubelet Container Runtime Interface (CRI)

CRI-O Components

• OCI compatible runtime
• Containers/storage
• Containers/image
• Networking (CNI)
• Container monitoring (conmon)
• Security

The Container Process Lifecycle

Setting up CRI-O

• Runtime dependencies
• CNI networking
• Running with Kubernetes

Lauching an Application in a Pod

• Creating a pod

Downloading Container Images

• Trust and image verification

Testing the Container

• Connecting, stopping and deleting a pod

Managing Container Images

• Image layers, overlay filesystems
• Monitoring and logging
• Resource isolation

Running other OCI-Compliant Runtimes

• dockerd
• containerd
• rktlet
• frakti

Troubleshooting

Summary and Conclusion

Duration

14 hours (usually 2 days including breaks)

Requirements

• An understanding of cloud computing
• Experience with server infrastructure

Audience

• Cloud Engineers

Overview

Kubernetes is an open source container-orchestration system for automating CI/CD management. Spinnaker is an open source multi-cloud CD platform for releasing software with efficiency. With Kubernetes and Spinnaker, users can employ immutable structures, deployment pipelines, and cluster management.

This instructor-led, live training (online or onsite) is aimed at cloud engineers who wish to use Kubernetes and Spinnaker for CI/CD operations.

By the end of this training, participants will be able to:

• Build on the Kubernetes platform to accelerate cloud targeted deployments.
• Integrate Spinnaker with Docker and Git for automating the delivery of code to pipelines.
• Automate and manage CD pipelines, while choosing from a variety of CI tool options.

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Course Outline

Introduction

Continuous Integration and Continuous Delivery Overview

• What is CI?
• What is CD?

Spinnaker Overview

• What is Spinnaker?
• Deployment strategies and pipelines
• Kubernetes and Spinnaker

Preparing the Development Environment

• Installing and configuring Spinnaker

Spinnaker Quick Start

• Deploying Spinnaker
• Creating an app
• Adding manifests

Building Pipelines

• Building a pipeline
• Adding artifacts
• Defining pipelines
• Setting up manual decisions and roll backs

Deploy to Kubernetes

• Configuring Kubernetes
• Adding a container app
• Deploying on Kubernetes

Summary and Conclusion

Duration

21 hours (usually 3 days including breaks)

Requirements

• An understanding of Docker and Kubernetes basics.
• Experience with the Linux command line.
• An Amazon AWS account with at least 10 USD on it.

Audience

• Developers
• System Administrators
• DevOps Engineers

Overview

There are a number of options for deploying Docker and Kubernetes on AWS, including Amazon Elastic Container Service, Amazon ECS for Kubernetes, AWS Fargate, and Amazon EC2.

This instructor-led, live training (online or onsite) is aimed at engineers who wish to evaluate each of these services to make an informed decision about which to deploy within their organization.

By the end of this training, participants will be able to:

• Set up a development environment that includes all needed tools to start developing.
• Set up, configure and deploy a series of demo containers using a number of different approaches.
• Understand the architectural and design differences among different Docker/Kubernetes solutions within AWS.
• Automate the deployment of Docker containers.
• Set up a continuous integration and deployment pipeline.
• Integrate Docker and Kubernetes into an existing continuous integration system.

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Course Outline

Introduction

Overview of Docker and Kubernetes on AWS

Preparing the Development Environment

Using Amazon Elastic Container Service

• Creating a Containerized Application
• Deploying the Application

Using Amazon ECS for Kubernetes

• Creating a Containerized Application
• Deploying the Application

AWS Fargate

• Creating a Containerized Application
• Deploying the Application

Amazon EC2

• Creating a Containerized Application
• Deploying the Application

Setting up a Continuous Integration Pipeline

Integrating Docker and Kubernetes with an existing Continuous Integration System

Troubleshooting

Summary and Conclusion

Duration

14 hours (usually 2 days including breaks)

Requirements

• Previous experience working with Kubernetes

Audience

• DevOps engineers
• Developers

Overview

Kubernetes offers features for securing a cluster and its applications. The out-of-the-box settings, however, may not provide full protection from hackers and unintentionally harmful actors.

This instructor-led, live training (online or onsite) is aimed at engineers who wish to secure a Kubernetes cluster beyond the default security settings.

By the end of this training, participants will be able to:

• Understand the vulnerabilities that are exposed by a default Kubernetes installation.
• Prevent unauthenticated access to the Kubernetes API, database, and other services.
• Protect a Kubernetes cluster from accidental or malicious access.
• Put together a comprehensive security policy and set of best practices.

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Course Outline

Introduction

Overview of the Kubernetes API and Security Features

• Access to HTTPS endpoints, Kubernetes API, nodes, and containers
• Kubernetes Authentication and Authorization features

How Hackers Attack Your Cluster

• How hackers find your etcd port, Kubernetes API, and other services
• How hackers execute code inside your container
• How hackers escalate their privileges
• Case study: How Tesla exposed its Kubernetes cluster

Setting up Kubernetes

• Choosing a distribution
• Installing Kubernetes

Using Credentials and Secrets

• The credentials life cycle
• Understanding secrets
• Distributing credentials

Controlling Access to the Kubernetes API

• Encrypting API traffic with TLS
• Implementing authentication for API servers
• Implementing authorization for different roles

Controlling User and Workload Capabilities

• Understanding Kubernetes policies
• Limiting resource usage
• Limiting container privileges
• Limiting network access

Controlling access to nodes

• Separating workload access

Protecting Cluster Components

• Restricting access to etcd
• Disabling features
• Changing, removing and revoking credentials and tokens

Securing Container Image

• Managing Docker and Kubernetes images
• Building secure images

Controlling Access to Cloud Resources

• Understanding cloud platform metadata
• Limiting permissions to cloud resources

Evaluating Third Party Integrations

• Minimizing the permissions granted to third party software
• Evaluating components that can create pods

Establishing a Security Policy

• Reviewing the existing security profile
• Creating a security model
• Cloud native security considerations
• Other best practices

Encrypting Inactive Data

• Encrypting backups
• Encrypting the entire disk
• Encrypting secret resources in etcd

Monitoring Activity

• Enabling audit logging
• Auditing and governing the software supply chain
• Subscribing to security alerts and updates

Summary and Conclusion

Duration

21 hours (usually 3 days including breaks)

Requirements

• Proficiency in Python programming experience
• Intermediate experience with Kubernetes concepts and principles
• An understanding of containerization and cloud technologies
• Experience with Linux distributions and CLI

Audience

• Developers
• DevOps Engineers

Overview

Serverless is a DevOps architecture that allows the creation and deployment of highly-scalable enterprise applications without the provisioning of any server. Kubernetes is an open-source platform for building container-based and cloud-native projects. A serverless framework can be integrated with Kubernetes to provide the automated hosting infrastructure necessary to run CaaS and FaaS implementations.

This instructor-led, live training (online or onsite) is aimed at developers and DevOps engineers who wish to utilize a serverless approach for building enterprise applications in Kubernetes.

By the end of this training, participants will be able to:

• Setup and configure the Kubernetes system to start developing with a serverless architecture.
• Understand the concepts and principles foundational to serverless environments.
• Operate toolchains necessary to serverless development and integrate it with Kubernetes components.
• Practice their skill in Python programming language and apply it to implement  serverless systems.
• Secure enterprise applications that are deployed through a serverless framework on Kubernetes.
• Utilize modern cloud computing methods in optimizing DevOps task processing workflows.

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Course Outline

Introduction

Overview of Serverless Features and Architecture

• How does serverless development work?
• What are requisites to a serverless approach?

Overview of CNCF Ecosystem and Serverless Environments

• Serverless Container as a Service v.s. Serverless Function as a Service

Getting Started with Serverless on Kubernetes

• Choosing the right serverless framework for Kubernetes
• Fission v.s. Kubeless v.s. Knative
• Knative v.s. OpenFaaS

Overview of Additional FaaS Providers for Serverless Frameworks

Overview of OpenFaaS Toolchain and Features

• Why should you get started with OpenFaaS?
• What tools can be integrated with OpenFaaS

Setting Up the Kubernetes System for Serverless Development

• Installing and configuring the necessary frameworks and tools

Operating the Core Serverless Framework Tools and Utilizing the API

• Navigating the dashboard and working with the UI or CLI

Overview of FaaS Implementations and Kubernetes Serverless Applications

• Cold start v.s. warm start

Creating a Python Function in Kubernetes Using a Serverless Framework

Storing Code Templates and Sharing Functions in Repositories

• Versioning serverless Kubernetes projects

Testing Python Functions and Optimizing Performance Metrics

• Working with invocation metrics

Implementing Automatic Scaling for Management of Resources Response

• Applying changes to functions

Adding Dependencies to Functions and Creating Native Extensions

Storing Kubernetes Secrets in Serverless Functions

• Leveraging container images and pod definitions

Securing Kubernetes Serverless Functions and Building Authentication Functionalities

• Working with TLS protocol

Deploying Python Functions with Serverless on Kubernetes

• Employing Serverless CI/CD pipelines for deployment
• Customizing component URLs

Monitoring Function Lifecycle and Reviewing Request Logs

Troubleshooting

Summary and Conclusion

Duration

14 hours (usually 2 days including breaks)

Requirements

• An understanding of DevOps

Audience

• DevOps Engineers

Overview

Gitlab is a DevOps lifecycle platform that provides CI/CD features for project planning and management. Kubernetes is an orchestration system for automating application deployment. Using Gitlab and Kubernetes, users can automate builds and deployment to containerized cloud environments.

This instructor-led, live training (online or onsite) is aimed at DevOps engineers who wish to use Kubernetes and Gitlab to automate the DevOps lifecycle.

By the end of this training, participants will be able to:

• Automate application builds, tests, and deployments.
• Create an automated build infrastructure.
• Deploy an application to a containerized cloud environment.

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Course Outline

Introduction

Continuous Integration and Continuous Delivery Overview

• What is CI?
• What is CD?

Gitlab at a Glance

• What is Gitlab?
• Gitlab features
• Gitlab CI

Preparing the DevOps environment

• Installing and configuring Auto DevOps in Gitlab

Kubernetes

• Integrating Kubernetes
• Creating Kubernetes clusters
• Creating a Kubernetes instance
• Using Gitlab SSH keys

Stages, Artifacts, and Dependencies

• Placing jobs into stages
• Using cache
• Defining and using Artifacts

Gitlab Auto DevOps

• Working with Helm
• Using Auto DevOps
• Configuring Gitlab runner
• Adding repository

Automated Deployment

• Deploying to Kubernetes

Debugging

• Handling errors

Testing

• Integration and functional testing

Monitoring

• Using Prometheus
• Gathering metrics

Securing

• Hardening pipelines and pipeline systems

Troubleshooting

Summary and Next Steps

Duration

7 hours (usually 1 day including breaks)

Requirements

• Experience with the Linux command line
• Experience managing containers with Kubernetes
• A general understanding of “continuous integration” (CI) / “continuous deliver” (CD) concepts

Audience

• Developers
• DevOps engineers

Overview

This instructor-led, live training (online or onsite) is aimed at engineers who wish to use Helm to streamline the process of installing and managing Kubernetes applications.

By the end of this training, participants will be able to:

• Install and configure Helm.
• Create reproducible builds of Kubernetes applications.
• Share applications as Helm charts.
• Run third-party applications saved as Helm charts.
• Manage releases of Helm packages.

Format of the course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.
• To learn more about Helm, please visit: https://helm.sh/

Course Outline

Introduction

• Helm package manager as a Continuous Integration (CI) / Continous Deployment (CD) tool.

Installing and Configuring Kubernetes and Helm

Refresher on Kubernetes Cluster Architecture and Docker

Overview of Helm Features and Architecture

Navigating the Kubernetes Dashboard and Helm CLI

Setting up a Helm Repository

Creating a Helm Chart

Deploying a Kubernetes Application

Managing the Application

Handling Namespaces

Monitoring and Logging

Securing Helm: Authentication and Authorization

Managing the Life Cycle with Hooks

Testing Helm

Working with Database and APIs

Deploying Complex Applications to Production

Troubleshooting

Summary and Next Steps

Duration

14 hours (usually 2 days including breaks)

Requirements

• An understanding of container and container orchestration concepts.
• Experience with Kubernetes.

Audience

• DevOps engineers
• System administrators
• Developers
• Software engineers

Overview

Kubernetes can be run on a variety of platforms, from a local server, to a virtual or bare-metal server in the cloud, to a SaaS based cloud service. In all cases, the Kubernetes ecosystem includes tools for installing, managing, and testing Kubernetes clusters.

This instructor-led, live training (online or onsite) is aimed at engineers who wish to evaluate, select and deploy the most appropriate Kubernetes solution for their specific situation.

By the end of this training, participants will be able to:

• Install and configure a Kubernetes cluster on premise and in the cloud.
• Evaluate different cloud-hosted Kubernetes solutions and understand the advantages over a self-hosted approach.
• Compare different tools for testing, managing, and monitoring a Kubernetes cluster.

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Course Outline

Introduction

Overview of Kubernetes Features and Architecture

Understanding Kubernetes Runtimes, Networking, Scheduling and Orchestration，

Options for Installing, Deploying and Running Kubernetes

• Local Server
• Cloud Server
• Hosted Solution

Assessing the Organization’s Needs

• Existing infrastructure, skill set, maintenance requirements, licensing etc.

Planning a Kubernetes Deployment

• Schedule, cost, talent resources, etc.

Tools in the Kubernetes Ecosystem

• Minishift, MicroK8s, k3s, Ubuntu on LXD, etc.

Kubernetes Local Server (On-Premise) and Cloud Server Solutions

• A simple Docker installation
• Red Hat OpenShift
• Heptio
• Platform9
• Others: Giant Swarm, CoreOS Tectonic, Rancher, etc.

Hosted Kubernetes Platforms

• Google Kubernetes Engine (GKE)
• Azure Container Service (AKS)
• Amazon Elastic Container Service for Kubernetes (EKS)
• Others: AppsCode, AppUiO, DigitalOcean, etc.

Kubernetes Security

• Private network security
• Cloud provider security
• Hosted provider security

Custom Kubernetes Solutions

• Cloud Foundry Container Runtime (CFCR)
• Kubernetes on Ubuntu
• Rancher Kubernetes Engine (RKE)

Integration Solutions

• Third-party schedulers, resource managers, and/or lower level platforms

Avoiding (or Embracing) Vendor Lock-in

• The risks of customizing
• The cost of lock-in

Bringing It All Together

• Business and technical challenges
• Communicating across teams
• Preparing for change

Summary and Conclusion

Duration

21 hours (usually 3 days including breaks)

Requirements

• Familiarity with using the Linux command line, Linux file system, Linux networking, bash scripting.
• An understanding of programming concepts and methodologies.
• Familiarity with Docker and Linux containers technology.
• Familiarity with Kubernetes concepts.

Overview

The evolution of microservices and containers in recent years has significantly changed how we design, develop, deploy and run software. Modern applications must be optimized for scalability, elasticity, failure, and change. Driven by these new demands, modern architectures require a different set of patterns and practices. In this training, we examine ways to identify, understand and adjust to these new requirements.

Audience
This training is intended for people who are somewhat familiar with container technology and with Kubernetes concepts but are perhaps lacking the real world experience. It is based on use cases, and lessons learnt from real life projects with the intention of making people inspired to create and manage even better cloud native applications.

• Developers
• Operations
• DevOps
• QA Engineers
• IT Project Managers

Format of the Course

• Interactive lecture and discussion
• Lots of exercises and practice
• Handson implementation in a live-lab environment

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Course Outline

• Introduction
• Recap about Linux containers technology
• Recap about Kubernetes basic concepts
• Microservice based applications
• The 12 Factors App Principles
• Foundational Patterns: Distributed Primitives, Predictable Demands, Dynamic Placement, Declarative Deployment, Observable Interior, and Life Cycle Conformance.
• Behavioral Patterns: Batch Jobs, Scheduled Jobs, Daemon Services, Singleton Services and Self Awareness.
• Structural Patterns: Sidecar, Initializer, Ambassador, and Adapter.
• Configuration Patterns: Env Var Configuration, Configuration Resources, Configuration Templates, and Immutable Configuration.
• Summary and Conclusion

Duration

14 hours (usually 2 days including breaks)

Requirements

• An understanding of containers and Kubernetes basics
• Experience with the Linux command line
• An Amazon AWS account with at least 10 USD on it.

Overview

EKS is a self-managed Kubernetes-as-a-service offering from AWS. EKS is fully scalable and customizable and allows a Kubernetes deployment to mimic and/or integrate with an existing on-premise Kubernetes setup.

In this instructor-led, live training, participants will learn how to set up and manage a production-scale container environment using Kubernetes on EKS. 

By the end of this training, participants will be able to:

• Configure and manage Kubernetes on EKS
• Migrate an existing Kubernetes environment from on-premise to AWS cloud
• Integrate Kubernetes with third-party continuous integration (CI) software
• Ensure high availability and disaster recovery in Kubernetes
• Understand and adopt the tools available to efficiently manage EKS

Audience

• Developers
• System Administrators
• DevOps Engineers

Format of the Course

• Part lecture, part discussion, exercises and heavy hands-on practice in a live-lab environment.

Note

• To request a customized training for this course, please contact us to arrange.

Course Outline

Introduction

Overview of Docker Containers And Kubernetes in AWS

Overview of AWS Container Management Offerings and Architecture

Getting Started with Kubernetes on EKS

Building A Kubernetes Cluster On EKS 

Networking Kubernetes Pods

Migrating from On-premise to AWS.

Integrate Kubernetes with Continuous Integration (CI).

Ensuring High Availability and Disaster Recovery in Kubernetes.

Using Fargate to Manage EKS

Troubleshooting

Summary and Conclusion