Nanodegree key: nd9991
Version: 3.0.0
Locale: en-us
In this program, you’ll develop the skills you need to join the rapidly growing cloud devops field.
Content
Part 01 (Elective): Prerequisite: Networking
This lesson will cover the basic knowledge and tools required to configure and investigate network connectivity.
-
Module 01: Prerequisite: Networking
-
Lesson 01: Networking
This lesson will cover the basic knowledge and tools required to configure and investigate network connectivity.
- Concept 01: Interview
- Concept 02: Lesson Map & Learning Objectives
- Concept 03: Network Communication Model
- Concept 04: Addressing
- Concept 05: Addressing and Networks
- Concept 06: OSI Model
- Concept 07: Switching
- Concept 08: Frame Structure
- Concept 09: Switching At Scale
- Concept 10: Virtual LANs
- Concept 11: Routing
- Concept 12: Wireshark
- Concept 13: Domain Name System
- Concept 14: Types of DNS Records
- Concept 15: DNS Hierarchy
- Concept 16: Load Balancing
- Concept 17: Load Balancing Approaches
- Concept 18: Outro
-
Part 02 : Cloud Fundamentals
The cloud has become a key enabler for innovation with beneficial features like high availability, unlimited capacity, and on-demand scalability and elasticity. Learn the fundamentals of cloud computing while being introduced to compute power, security, storage, networking, messaging, and management services in the cloud. While learning the fundamentals, you will explore tools and services offered by Amazon Web Services (AWS) through interactive hands-on exercises. By the end of the course, you will have deployed your first website to AWS, and you will be prepared to continue your learning journey in the Cloud Developer Nanodegree program.
-
Module 01: Cloud Fundamentals
-
Lesson 01: Cloud Computing
Learn the basics of cloud computing including cloud deployment models, benefits, and popular options.
- Concept 01: Course Introduction
- Concept 02: Instructor Introduction
- Concept 03: Lesson Introduction
- Concept 04: What is Cloud Computing?
- Concept 05: Types of Cloud Computing
- Concept 06: Cloud Computing Deployment Model
- Concept 07: Common Benefits
- Concept 08: Options
- Concept 09: Services
- Concept 10: Global Infrastructure
- Concept 11: Shared Responsibility Model
- Concept 12: Lesson Recap
-
Lesson 02: Foundational & Compute Service
Learn why we need servers, compute power, and security.
- Concept 01: Lesson Introduction
- Concept 02: Why do we need servers in the cloud?
- Concept 03: Elastic Cloud Compute (EC2)
- Concept 04: EC2 - Launch an Instance
- Concept 05: EC2 Dashboard
- Concept 06: EC2 - Connect to Linux Instance
- Concept 07: Elastic Block Store (EBS)
- Concept 08: EC2 - Create an EBS Volume
- Concept 09: EC2 - EBS Dashboard
- Concept 10: Why do we need security in the cloud for our servers?
- Concept 11: Virtual Private Cloud (VPC)
- Concept 12: VPC Dashboard
- Concept 13: VPC - Create a VPC
- Concept 14: VPC - Your VPCs
- Concept 15: VPC - Network ACL
- Concept 16: Lab - Launch an EC2 Instance
- Concept 17: Why do we need compute power in the cloud?
- Concept 18: Lambda
- Concept 19: Lambda - Create a Function
- Concept 20: Lab - Create and execute a Lambda
- Concept 21: Elastic Beanstalk
- Concept 22: Lab - Deploy Sample App to Elastic Beanstalk
- Concept 23: Lesson Recap
-
Lesson 03: Storage & Content Delivery
Learn why we need storage and content delivery in the cloud.
- Concept 01: Lesson Introduction
- Concept 02: Why do we need storage in the cloud?
- Concept 03: S3 & Glacier
- Concept 04: S3 - Create a Bucket
- Concept 05: DynamoDB
- Concept 06: DynamoDB - Create a table
- Concept 07: Lab - DynamoDB
- Concept 08: Relational Database Service (RDS)
- Concept 09: RDS - Create MySQL Database
- Concept 10: RedShift
- Concept 11: Lab - RDS
- Concept 12: Why do we need content delivery in the cloud?
- Concept 13: Cloud Front
- Concept 14: Demo - Cloud Front
- Concept 15: Lab - S3 & Cloud Front
- Concept 16: Lesson Recap
-
Lesson 04: Security
Learn the importance of security in the cloud.
-
Lesson 05: Networking & Elasticity
Learn the basics of networking and elasticity in the cloud.
- Concept 01: Lesson Introduction
- Concept 02: Why do we need networking in the cloud?
- Concept 03: Route 53
- Concept 04: Why do we need elasticity in the cloud?
- Concept 05: EC2 Auto Scaling
- Concept 06: EC2 - Create Auto Scaling group
- Concept 07: EC2 - Auto Scaling Group
- Concept 08: Elastic Load Balancing
- Concept 09: EC2 - Elastic Load Balancing
- Concept 10: EC2 - Lab NLB
- Concept 11: Lab - EC2 Auto Scaling
- Concept 12: Lesson Recap
-
Lesson 06: Messaging & Containers
Learn the basics of messaging and containers in the cloud.
- Concept 01: Lesson Introduction
- Concept 02: Why do we need messaging in the cloud?
- Concept 03: Simple Notification Service (SNS)
- Concept 04: Demo - Simple Notification Service (SNS)
- Concept 05: Why do we need queuing technology?
- Concept 06: Simple Queue Service (SQS)
- Concept 07: SQS - Create a Queue
- Concept 08: Lab - SNS
- Concept 09: Why do we need containers?
- Concept 10: Elastic Container Service (ECS)
- Concept 11: Demo - Elastic Container Service
- Concept 12: ECS - Create a Cluster
- Concept 13: Lesson Recap
-
Lesson 07: AWS Management
Learn why we need logging, auditing, and resource management in the cloud.
- Concept 01: Introduction
- Concept 02: Why do we need logging and auditing in the cloud?
- Concept 03: Cloud Trail
- Concept 04: CloudTrail - Create a Trail
- Concept 05: Cloud Watch
- Concept 06: Demo - Cloud Watch
- Concept 07: Lab - Cloud Watch
- Concept 08: What is Infrastructure as Code and why do we need it?
- Concept 09: Cloud Formation
- Concept 10: Demo - Cloud Formation
- Concept 11: Lab - Cloud Formation
- Concept 12: AWS Command Line Interface (CLI)
- Concept 13: Demo - AWS Command Line Interface (CLI)
- Concept 14: AWS - Install and Configure CLI v2
- Concept 15: Lab - Interacting with S3 Buckets via the CLI
- Concept 16: Lesson Recap
- Concept 17: Course Recap
-
Lesson 08: Deploy Static Website on AWS
In this project, you will deploy a static website to AWS.
-
Part 03 : Deploy Infrastructure as Code (IAC)
With the advent of cloud computing, along came several tools that enabled us to deploy the underlying infrastructure components that provide security and services to our servers by writing scripts. In this course, you’ll learn how to deploy this infrastructure using CloudFormation, AWS’ tool for Infrastructure as Code.
You will use CloudFormation to deploy Infrastructure patterns that are used in the industry broadly and can be readily used to deploy any cloud application. Like in the real world, you will begin with initial business requirements that you will turn into Cloud Architecture Diagrams. Then you will deploy this architecture using CloudFormation.
-
Module 01: Deploy Infrastructure as Code (IAC)
-
Lesson 01: Getting Started with CloudFormation
Set up the necessary tools to get started with AWS CloudFormation and deploy your first server.
- Concept 01: Introduction
- Concept 02: Course Overview
- Concept 03: What is DevOps
- Concept 04: Why you need DevOps
- Concept 05: What are the benefits of Cloud DevOps?
- Concept 06: Set up Tools
- Concept 07: Creating Access Key ID for IAM User
- Concept 08: Configuring AWS CLI
- Concept 09: Adding Additional Keys
- Concept 10: Understanding CloudFormation
- Concept 11: Getting Started With CloudFormation Script
- Concept 12: Create a VPC: Manually
- Concept 13: Exercise - Create a VPC: Automated
- Concept 14: Exercise - EC2 Instance with an Admin Role
- Concept 15: Conclusion
- Concept 16: Challenge 1
-
Lesson 02: Infrastructure Diagrams
Convert business requirements into infrastructure diagrams and understand the principles behind design choices.
- Concept 01: Introduction
- Concept 02: Generalizing to other cloud providers
- Concept 03: Setting up Lucidcharts
- Concept 04: Exercise: Setting Up Lucid Charts
- Concept 05: Diagramming AWS Accounts and Regions
- Concept 06: Exercise: Diagramming AWS accounts & regions
- Concept 07: Diagramming Availability Zones
- Concept 08: Exercise: Diagramming Availability Zones
- Concept 09: Virtual Private Cloud
- Concept 10: Exercise: Virtual Private Cloud
- Concept 11: Public vs Private Subnets
- Concept 12: Exercise: Public vs Private Subnets
- Concept 13: IGW Internet Gateway
- Concept 14: Exercise: IGW Internet Gateway
- Concept 15: Network Address Translation
- Concept 16: Exercise: NAT's
- Concept 17: Autoscaling groups
- Concept 18: Exercise: Autoscaling Groups
- Concept 19: Load Balancers
- Concept 20: Exercise: Load Balancers
- Concept 21: Security Groups
- Concept 22: Exercise: Security Groups
- Concept 23: Routing Table
- Concept 24: Exercise: Routing Table
- Concept 25: S3
- Concept 26: Exercise: S3
- Concept 27: Reviewing Our Diagram
- Concept 28: Conclusion
-
Lesson 03: Networking Infrastructure
Learn about various networking components that can be used in a VPC.
-
Lesson 04: Servers and Security Groups
Implement security groups and understand the concept of least-privilege as it applies to network traffic
- Concept 01: Introduction
- Concept 02: Setting Up Our Environment
- Concept 03: Understanding Security Groups
- Concept 04: Security Groups
- Concept 05: Creating Autoscaling Group
- Concept 06: Launch Configuration
- Concept 07: Debugging Launch Configuration
- Concept 08: Launch Templates
- Concept 09: Adding Target Groups and Listeners
- Concept 10: Updating the Stack with the Load Balancer
- Concept 11: Debugging Our Security Group
- Concept 12: Connect to private servers via a Jumpbox
- Concept 13: Final Review
- Concept 14: Conclusion
- Concept 15: Challenge 3
-
Lesson 05: Storage and Databases
Deploy relational database and encryption service for your application.
- Concept 01: Introduction
- Concept 02: RDS Databases (Part One)
- Concept 03: RDS Databases (Part Two)
- Concept 04: RDS - Create Aurora database
- Concept 05: RDS Database (Part Three)
- Concept 06: RDS Database (Part Four)
- Concept 07: S3 (Part One)
- Concept 08: S3 (Part Two)
- Concept 09: Key Points
- Concept 10: Exercises
- Concept 11: Conclusion
-
Lesson 06: Deploy a high-availability web app using CloudFormation
In this project, you’ll deploy web servers for a highly available web app using CloudFormation.
Project Description - Deploy a high-availability web app using CloudFormation
Project Rubric - Deploy a high-availability web app using CloudFormation
-
Lesson 07: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
- Concept 01: Prove Your Skills With GitHub
- Concept 02: Introduction
- Concept 03: GitHub profile important items
- Concept 04: Good GitHub repository
- Concept 05: Interview with Art - Part 1
- Concept 06: Identify fixes for example “bad” profile
- Concept 07: Quick Fixes #1
- Concept 08: Quick Fixes #2
- Concept 09: Writing READMEs with Walter
- Concept 10: Interview with Art - Part 2
- Concept 11: Commit messages best practices
- Concept 12: Reflect on your commit messages
- Concept 13: Participating in open source projects
- Concept 14: Interview with Art - Part 3
- Concept 15: Participating in open source projects 2
- Concept 16: Starring interesting repositories
- Concept 17: Next Steps
-
Part 04 : Build CI/CD Pipelines, Monitoring & Logging
In this course, you’ll learn the process of taking software from source code to deployment and beyond. You’ll learn about automated testing, choosing the right deployment strategy for your business needs and deploying appropriate CI/CD pipelines. You’ll also learn about monitoring and logging to ensure that your application is running at peak performance and stays that way.
You’ll also learn to manage and make changes to your servers in an automated way, using Ansible, a leading Configuration Management tool.
-
Module 01: Build CI/CD Pipelines, Monitoring & Logging
-
Lesson 01: Continuous Integration and Continuous Deployment
Set up Jenkins environment and learn the fundamentals of pipelines
- Concept 01: Introduction
- Concept 02: Course Overview
- Concept 03: Interview: Career Skills
- Concept 04: What is CI/CD and a Pipeline?
- Concept 05: AWS Setup
- Concept 06: IAM and EC2 Setup
- Concept 07: AWS Setup Quiz
- Concept 08: Jenkins Intro
- Concept 09: EC2 - Connect to Linux Instance
- Concept 10: Installing Jenkins
- Concept 11: Install Blue Ocean Plugin into Jenkins
- Concept 12: Jenkins Quiz
- Concept 13: Review and Practice Exercises
-
Lesson 02: Jenkins Pipeline and Deployment Strategies
Managing the complexity of CI/CD and choosing the correct deployment strategy
- Concept 01: Introduction
- Concept 02: Install AWS Plugin into Jenkins
- Concept 03: Intro to Blue Ocean
- Concept 04: Adding a Repo to a Pipeline
- Concept 05: Multiple Pipelines
- Concept 06: Pipeline Triggers
- Concept 07: Pipeline Testing
- Concept 08: Security Testing with Aqua
- Concept 09: Deployment Strategies
- Concept 10: Deployment Big Picture
- Concept 11: Deployment Practice
-
Lesson 04: Monitoring
Configuring Monitoring with Prometheus and ELK Stack
-
Lesson 05: Jenkins Pipelines on AWS
In this project you will deploy and run an instance on AWS, configure Jenkins, and create a pipeline to deploy a static website on S3.
-
Part 05 : Microservices at Scale using AWS & Kubernetes
In this course, you learn to create and deploy a kubernetes cluster, configure kubernetes autoscale and load test a kubernetes application. You’ll learn to operationalize both existing and new microservices and apply containers best practices. You’ll learn to deploy Machine Learning microservices that are elastic and fault tolerant. You’ll learn to pick the appropriate abstraction for microservices: Serverless (AWS Lambda) or Container Orchestration (Kubernetes).
-
Module 01: Microservices at Scale using AWS & Kubernetes
-
Lesson 01: Deploy an Event-Driven Microservice
Learn about cloud-native applications and deploy functions as a service (FaaS) using AWS Lambda and Cloud9.
- Concept 01: Lesson Outline
- Concept 02: Functions as a Service (FaaS)
- Concept 03: A Model for Serverless
- Concept 04: Benefits of FaaS
- Concept 05: Cloud-Native
- Concept 06: Characteristics of Cloud-Native Systems
- Concept 07: AWS Account & Resources
- Concept 08: Cloud9 Environment
- Concept 09: Lambda Functions
- Concept 10: Deploying and Testing
- Concept 11: Tutorial: Making Change
- Concept 12: Event-Handling
- Concept 13: Events & Response
- Concept 14: Create a Test
- Concept 15: Deploy & Use API Gateway
- Concept 16: Creating a Virtual Environment
- Concept 17: Exercise: Wikipedia
- Concept 18: Exercise Code
- Concept 19: Wikipedia Example
- Concept 20: Test & Response
- Concept 21: Summary
-
Lesson 02: Using Docker Format Containers
Setup a local development environment and learn to run Docker containers, locally. Learn how to lint and test some source code and Docker files.
- Concept 01: Docker Containers
- Concept 02: Exercise: Setting Up a Local Environment
- Concept 03: Makefiles
- Concept 04: Exercise: Create A Basic Makefile
- Concept 05: Install Docker
- Concept 06: Linting and CircleCI
- Concept 07: Running Dockerfiles
- Concept 08: Exercise: Deploying to Amazon ECR
- Concept 09: Summary
-
Lesson 03: Containerization of an Existing Application
Build and run a containerized application, specifying the source code, app dependencies, and writing a complete Dockerfile.
-
Lesson 04: Container Orchestration with Kubernetes
Deploy an application on a Kubernetes cluster. Learn how the components of a cluster can be used to automatically scale resources.
-
Lesson 05: Operationalizing Microservices
Learn about continuous integration and development (CI/CD pipeline) and implement fault-tolerance and load tests to create more robust applications.
-
Lesson 06: Operationalize a Machine Learning Microservice API
In this project, you will continue your work on operationalizing microservices by deploying a machine learning inference API using docker and kubernetes.
Project Description - Operationalize a Machine Learning Microservice API
Project Rubric - Operationalize a Machine Learning Microservice API
-
Lesson 07: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
- Concept 01: Get Opportunities with LinkedIn
- Concept 02: Use Your Story to Stand Out
- Concept 03: Why Use an Elevator Pitch
- Concept 04: Create Your Elevator Pitch
- Concept 05: Use Your Elevator Pitch on LinkedIn
- Concept 06: Create Your Profile With SEO In Mind
- Concept 07: Profile Essentials
- Concept 08: Work Experiences & Accomplishments
- Concept 09: Build and Strengthen Your Network
- Concept 10: Reaching Out on LinkedIn
- Concept 11: Boost Your Visibility
- Concept 12: Up Next
-
Part 06 : Capstone
The purpose of the cloud devops capstone project is to give you a chance to combine what you've learned throughout the program. This project will be an important part of your portfolio that will help you achieve your cloud development-related career goals.
In the capstone project, each project is unique to the student. You’ll build a CI/CD pipeline for a microservices application for different deployment strategies. Students define the scope of the project and select the right deployment strategy based on different business requirements.
-
Module 01: Capstone
-
Lesson 01: Capstone
In the capstone project, students define the scope of the project and select the right deployment strategy based on different business requirements.
-
Part 07 (Elective): Build CI/CD Pipelines, Monitoring & Logging (Updated)
-
Module 01: Build CI/CD Pipelines, Monitoring & Logging (Updated)
-
Lesson 01: Introduction to CI/CD
An introduction to this course, Continuous Integration, and Continuous Deployment!
- Concept 01: Meet Your Instructor
- Concept 02: Prerequisites
- Concept 03: Introduction to Continuous Delivery
- Concept 04: Continuous Delivery Is Important
- Concept 05: Stakeholders
- Concept 06: True North
- Concept 07: Principles of Continuous Delivery
- Concept 08: Course Outline
- Concept 09: Tools, Environment & Dependencies
- Concept 10: Project: Give Your Application Auto-Deploy Superpowers
- Concept 11: Good Luck!
-
Lesson 02: Continuous Integration and Continuous Deployment
In this lesson, we'll cover the fundamentals of CI/CD. Talk about the benefits, best practices, and look at the building blocks of pipelines!
- Concept 01: Introduction
- Concept 02: Big Picture
- Concept 03: Intuition
- Concept 04: Fundamentals of CI/CD
- Concept 05: Fundamentals Quizzes
- Concept 06: Benefits of CI/CD
- Concept 07: Exercise: Benefits
- Concept 08: Solution: Benefits
- Concept 09: Best Practices
- Concept 10: Deployment Strategies
- Concept 11: Blue Green Deployment
- Concept 12: Pipeline Building Blocks
- Concept 13: Exercise: Pipeline
- Concept 14: Solution: Pipeline
- Concept 15: CI/CD Tools
- Concept 16: Lesson Conclusion
-
Lesson 03: Building a Continuous Integration Pipeline
In this lesson, we'll learn about CI, the common building blocks of CI tools, and we'll build a CI pipeline!
- Concept 01: Introduction
- Concept 02: Big Picture
- Concept 03: Intuition
- Concept 04: Creating Pipelines
- Concept 05: Creating Jobs
- Concept 06: Exercise: Creating a Simple Workflow
- Concept 07: Solution: Creating a Simple Workflow
- Concept 08: Environment Variables
- Concept 09: Exercise: Environment Variables
- Concept 10: Solution: Environment Variables
- Concept 11: Triggering
- Concept 12: Exercise: Trigger Existing Workflow
- Concept 13: Solution: Trigger Existing Workflow
- Concept 14: Sharing Information
- Concept 15: Exercise: Sharing Files
- Concept 16: Solution: Sharing Files
- Concept 17: Reusable Job Code
- Concept 18: Exercise: Reusable Job Code
- Concept 19: Solution: Reusable Job Code
- Concept 20: Job Failures
- Concept 21: Exercise: Job Failures
- Concept 22: Solution: Job Failures
- Concept 23: Create a CI Pipeline
- Concept 24: Exercise: Create a CI Pipeline
- Concept 25: Solution: Create a CI Pipeline
- Concept 26: Lesson Conclusion
-
Lesson 04: Enabling Continuous Delivery with Deployment Pipelines
In this lesson, we'll design an Ansible playbook, write our own playbooks and build deployment-related jobs.
- Concept 01: Introduction
- Concept 02: Big Picture
- Concept 03: Intuition
- Concept 04: Configuration Management
- Concept 05: Design an Ansible Playbook
- Concept 06: Exercise: Define Ansible Playbook
- Concept 07: Solution: Define Ansible Playbook
- Concept 08: Build an Inventory File
- Concept 09: Exercise: Inventory File
- Concept 10: Solution: Inventory File
- Concept 11: Remote Control Using Ansible
- Concept 12: Exercise: Remote Control Using Ansible
- Concept 13: Solution: Remote Control Using Ansible
- Concept 14: Deployment Jobs
- Concept 15: Infrastructure Creation Jobs
- Concept 16: Exercise: Infrastructure Creation
- Concept 17: Solution: Infrastructure Creation
- Concept 18: Configuration and Deployment Jobs
- Concept 19: Exercise: Config and Deployment
- Concept 20: Solution: Config and Deployment
- Concept 21: Smoke Testing Jobs
- Concept 22: Exercise: Smoke Testing
- Concept 23: Solution: Smoke Testing
- Concept 24: Rollback Jobs
- Concept 25: Exercise: Rollback
- Concept 26: Solution: Rollback
- Concept 27: Production Candidate Promotion Jobs
- Concept 28: Exercise: Promote to Production
- Concept 29: Solution: Promote to Production
- Concept 30: Lesson Conclusion
-
Lesson 05: Monitoring Environments
In this lesson, we'll install Prometheus, set up alerts, and learn how to monitor data you receive.
- Concept 01: Introduction
- Concept 02: Big Picture
- Concept 03: Intuition About Monitoring
- Concept 04: The Case for Monitoring
- Concept 05: Monitoring Tools
- Concept 06: Set Up Prometheus
- Concept 07: Exercise: Prometheus
- Concept 08: Solution: Prometheus
- Concept 09: Exporters
- Concept 10: Exercise: Exporters
- Concept 11: Solution: Exporters
- Concept 12: Analyzing Metrics
- Concept 13: Exercise: Usage
- Concept 14: Solution: Usage
- Concept 15: Sending Alert Messages
- Concept 16: Exercise: Alerts
- Concept 17: Solution: Alerts
- Concept 18: Lesson Conclusion
- Concept 19: Course Recap
- Concept 20: Congratulations!
-