Docker and Kubernetes Fundamentals

Docker and Kubernetes Fundamentals

This intensive Docker and Kubernetes training course offers a combination of theoretical concepts as well as real-world hands-on labs, giving students the opportunity to apply their knowledge. The course covers essential Kubernetes and Docker skills and provides a basic introduction to Continuous Integration.

Who should attend

Developers, system architects, technical team leads, systems administrators, and DevOps professionals who want to understand and use Kubernetes in cloud environments.

Benefits

• Learn the fundamental uses of container technology and the architectural principles of how to apply containers to technical challenges.
• Create containers with both packaged solutions and custom software.
• Use the Docker and Kubernetes CLI environments to deploy solutions in local (Docker) and cluster (Kubernetes) environments.
• Learn how stateful services – such as databases, streaming solutions , and other specialty applications  – can be deployed in highly-available configurations with redundancy and service-discovery/load-balancing.
• Show how other components – can be used to integrate services within the Kubernetes platform.
• Explore how Docker and technologies such as Jenkins can be used to continuously test and build containers based on changes to source code.

Outline

1. Docker and Linux Container Technology: Introduction and Use-Cases
2. Modern Infrastructure Terminology
3. Virtualization
4. Hypervisors
5. Hypervisor Types
6. Type 1 Hypervisors
7. Type 2 Hypervisors
8. Type 1 vs Type 2 Processing
9. Paravirtualization
10. Virtualization Qualities (1/2)
11. Virtualization Qualities (2/2)
12. Disadvantages of Virtualization
13. Containerization
14. Virtualization vs Containerization
15. Where to Use Virtualization and Containerization
16. Containerization: High-Level
17. Popular Containerization Systems
18. What are Linux Containers
19. Docker
20. OpenVZ
21. Solaris Zones (Containers)
22. Container Orchestration Tools
23. Docker Swarm
24. Kubernetes
25. Mesos and Marathon
26. Docker Use-Cases
27. Microservices
28. Microservices and Containers / Clusters
29. Docker in Action
30. Docker Basics
31. Where Can I Run Docker?
32. Installing Docker Container Engine
33. Docker Toolbox
34. What is Docker?
35. Docker Architecture
36. Docker Architecture Diagram
37. Docker Images
38. Docker Containers
39. Docker Integration
40. Docker Services
41. Docker Application Container Public Repository
42. Docker Run Command
43. Starting, Inspecting, and Stopping Docker Containers
44. Docker Volume
45. Dockerfile
46. Docker Compose
47. Using Docker Compose
48. Dissecting docker-compose.yml
49. Specifying services
50. Dependencies between containers
51. Injecting Environment Variables
52. Managing Docker State
53. State and Data in Docker
54. Volumes
55. More About Volumes
56. Uses for Volumes
57. Working With Volumes
58. Create Volume
59. Use Volumes with Containers
60. Bind Mounts
61. Using Bind Mounts
62. tmpfs Mounts
63. Storing Data in the Container
64. Storage Drivers
65. Remote Data Storage
66. Networking
67. The Default Bridge Network
68. User-Defined Bridge Networks
69. Docker Network Commands
70. Creating a User-Defined Bridge Network
71. Open Container Initiative and Container Runtime Interface
72. Open Container Initiative (OCI)
73. Docker
74. Docker Engine Architecture
75. runC
76. containerd
77. containerd Benefits
78. CRI-O
79. CRI-O Components
80. Kubernetes and CRI-O
81. Using Container Runtimes with Minikube
82. Docker Runtime and Kubernetes
83. Putting Things Together
84. Kubernetes Architecture
85. Kubernetes Basics
86. What is Kubernetes?
87. Container Orchestration
88. Architecture Diagram
89. Components
90. Kubernetes Cluster
91. Master Node
92. Kube-Control-Manager
93. Nodes
94. Pod
95. Using Pods to Group Containers
96. Label
97. Label Syntax
98. Label Selector
99. Annotation
100. Persistent Storage
101. Resource Quota
102. Interacting with Kubernetes
103. Working with Kubernetes
104. Installation
105. Startup
106. Kubernetes Tools
107. kubectl Command Line Interface
108. API Proxy
109. Dashboard
110. Kubernetes Component Hierarchy
111. Deployments
112. Deployment Commands
113. Updating Deployments
114. Network Considerations
115. Services
116. Namespaces
117. Labels
118. Annotations
119. Other Useful Commands
120. Kubernetes Workload
121. Kubernetes Workload
122. Managing Workloads
123. Imperative commands
124. Imperative Object Configuration
125. Declarative Object Configuration
126. Configuration File Schema
127. Understanding API Version
128. Understanding API Version
129. Obtaining API Versions
130. Stateless Applications
131. Sample Deployment Manifest File
132. Working with Deployments
133. Stateful Applications
134. Sample Stateful Manifest File
135. Working with StatefulSet
136. Jobs
137. Sample Job Manifest File
138. Working with Batch Job
139. DaemonSets
140. Sample Daemon Manifest File
141. Rolling Updates
142. Scheduling and Node Management
143. Kubernetes Scheduler
144. Skip Kubernetes Scheduler
145. Scheduling Process
146. Scheduling Process - Predicates
147. Scheduling Process - Priorities
148. Scheduling Algorithm
149. Kubernetes Scheduling Algorithm
150. Scheduling Conflicts
151. Controlling Scheduling
152. Label Selectors
153. Node Affinity and Anti-affinity
154. Node Affinity Example
155. Node Antiaffinity Example
156. Taints and Tolerations
157. Taints and Tolerations - Example
158. Managing Networking
159. Kubernetes Networking Components
160. The Kubernetes Network Model
161. Networking Scenarios
162. Container-Container Communication
163. Pod-Pod Communication
164. 1.3 Pod-Service Communication
165. External-Service Communication
166. Accessing Applications
167. Useful Commands
168. Container Network Interface (CNI)
169. What is CNI's Role?
170. CNI Configuration Format
171. Sample CNI Configuration
172. Running the CNI Plugins
173. Managing Persistent Storage
174. Storage Methods
175. Container OS file system storage
176. Docker Volumes
177. Kubernetes Volumes
178. K8S Volume Types
179. Cloud Resource Types
180. configMaps
181. Creating configMaps from Literals
182. Creating configMaps from files
183. Using configMaps
184. emptyDir
185. Using an emptyDir Volume
186. Other Volume Types
187. Persistent Volumes
188. Creating a Volume
189. Persistent Volume Claim
190. Persistent Volume
191. Pod that uses Persistent Volume
192. Secrets
193. Creating Secrets from Files
194. Creating Secrets from Literals
195. Using Secrets
196. Security Context
197. Security Context Usage
198. Working with Helm
199. What is Helm?
200. Installing Helm
201. Helm and KUBECONFIG
202. Helm Features
203. Helm Terminology
204. Searching for Charts with helm CLI
205. Adding Repositories
206. Helm Hub - Search
207. Helm Hub - Chart Page
208. Installing a Chart
209. Upgrading a Release
210. Rolling Back a Release
211. Creating Custom Charts
212. Common Chart Files
213. Helm Templates
214. Installing A Custom Chart
215. Packaging Custom Charts
216. Logging, Monitoring, and Troubleshooting
217. Differences Between Logging and Monitoring
218. Logging in Kubernetes
219. Basic Logging
220. Logging Agents
221. Fluentd and Elastic Stack
222. Monitoring with Prometheus
223. Kubernetes and Prometheus - Metrics
224. Alerting
225. Debugging Pods
226. Debugging Nodes
227. Debugging Replication Controllers and Services
228. Upgrading Kubernetes
229. Upgrade Process
230. Determine Which Version to Upgrade To
231. Upgrade kubeadm
232. Upgrade Control Plane Node
233. Upgrade kubelet and kubectl
234. Upgrade Worker Nodes
235. Recovering From a Failure State
236. Continuous Integration Fundamentals
237. Jenkins Continuous Integration
238. Jenkins Features
239. Running Jenkins
240. Downloading and Installing Jenkins
241. Running Jenkins as a Stand-Alone Application
242. Running Jenkins on an Application Server
243. Installing Jenkins as a Windows Service
244. Different types of Jenkins job
245. Configuring Source Code Management(SCM)
246. Working with Subversion
247. Working with Git
248. Build Triggers
249. Schedule Build Jobs
250. Polling the SCM
251. Maven Build Steps
252. Configuring Jenkins to Access Kubernetes
253. Jenkins Pipeline
254. Jenkins Pipeline Output
255. Installing Jenkins Plugins
256. Lab Exercises
257. Creating a Docker Account and Obtain an Access Token
258. Managing Containers
259. Building Images
260. Dockerfiles
261. Getting Started with Docker Compose
262. Docker Volumes
263. Custom Network Management
264. Configuring Minikube/Kubernetes to Use a Custom Docker Account
265. Accessing the Kubernetes API
266. Working with Kubernetes Workloads
267. Scheduling and Node Management
268. Accessing Applications
269. Using Persistent Storage
270. Getting Started with Helm
271. Build CI Pipeline with Jenkins

Required Prerequisites

• Proficiency with the Linux Command Line Interface (CLI)
• Broad understanding of Linux system administration: Linux file system, networking, and bash scripting.
• Computer programming concepts and methodologies. Full code examples for the course are provided in the Python and Java programming languages.

‍