Nanodegree key: nd0044
Version: 4.1.17
Locale: en-us
Learn how to create server-side, data-driven web applications that support any front-end and can scale to support hundreds of thousands of users.
Content
Part 01 : Welcome to the Program!
-
Module 01: Welcome to the Program!
Part 02 : SQL and Data Modeling for the Web
You'll learn the skills needed to traverse the stack and develop an entire database-backed web application. By the end of the course, you'll have the fundamentals you need to start building web applications, including how to do Create, Read, Update, and Delete (CRUD) operations on a database, how to apply these operations across both databases and web applications, how to set up relationships between elements of an application, and ultimately how to think about important principles and patterns in building data models for a web application
-
Module 01: SQL and Data Modeling for the Web
-
Lesson 01: Instructor Interview
Meet your instructor!
-
Lesson 02: Course Introduction
Understand what this course will cover and the learning objectives achieved.
-
Lesson 03: Interacting with Databases
Interact with relational databases. Review SQL and the Client-Server Model. Use Postgres, understand DBAPIs, and use psycopg2.
- Concept 01: Lesson Overview
- Concept 02: Relational Databases
- Concept 03: Primary Keys & Foreign Keys
- Concept 04: Practice: SQL
- Concept 05: Execution Plan
- Concept 06: Client-Server Model
- Concept 07: Example: Jane's Store
- Concept 08: TCP/IP
- Concept 09: Connections and Sessions in TCP/IP
- Concept 10: Transactions
- Concept 11: Installing Postgres
- Concept 12: Practice: Postgres Command Line Applications
- Concept 13: Practice: Intro to psql
- Concept 14: Practice: Using psql - SQL Commands
- Concept 15: Using psql - Final remarks
- Concept 16: Other Postgres Clients
- Concept 17: DBAPIs and psycopg2
- Concept 18: Exercise 1: psycopg2: basic usage
- Concept 19: Exercise 2: psycopg2: string composition
- Concept 20: Exercise 3: psycopg2: fetching results
- Concept 21: psycopg2 conclusion
- Concept 22: Recap
-
Lesson 04: SQLAlchemy Basics
Learn to use SQLAlchemy and SQLAlchemy ORM to work with a relational database in Python.
- Concept 01: Lesson Overview
- Concept 02: Introduction
- Concept 03: Layers of Abstraction
- Concept 04: The Dialect
- Concept 05: The Connection Pool
- Concept 06: The Engine
- Concept 07: SQL Expressions
- Concept 08: SQLAlchemy ORM
- Concept 09: Mapping Between Tables and Classes
- Concept 10: Exercise 1: Hello App with Flask-SQLAlchemy - Part 1
- Concept 11: Exercise 2: Connecting to the Database
- Concept 12: db.Model and Defining Models
- Concept 13: Exercise 3: Syncing Models, db.create_all()
- Concept 14: Exercise 4: Inserting Records, Using Debug Mode
- Concept 15: Exercise: Experimenting in Interactive Mode
- Concept 16: SQLAlchemy Data Types
- Concept 17: SQLAlchemy Constraints
- Concept 18: Recap
-
Lesson 05: SQLAlchemy ORM in Depth
Get to know Model.query and the SQLAlchemy Object Lifecycle to master how to query for and change records in a database.
-
Lesson 06: Migrations
Handle changes to your database schema over time using a version control system involving migration files.
- Concept 01: Lesson Outline
- Concept 02: Introduction (Migrations Part 1)
- Concept 03: Migrations - Part 2
- Concept 04: Exercise: Flask-Migrate - Part 1
- Concept 05: Exercise: Flask-Migrate - Part 2
- Concept 06: Exercise: Flask-Migrate - Part 3
- Concept 07: Exercise: Flask-Migrate - Part 4
- Concept 08: Migrations Exercises Solution
- Concept 09: Recap
- Concept 10: Glossary
-
Lesson 07: Build a CRUD App with SQLAlchemy - Part 1
Build out the ability to read and create todo items in our To-do app, handling changes from the database to the views.
- Concept 01: Lesson Outline
- Concept 02: Introduction
- Concept 03: Exercise: Create a Dummy ToDo App
- Concept 04: Exercise or Demo: Reading ToDo items: The “R” in CRUD
- Concept 05: Exercise Solution
- Concept 06: Model View Controller (MVC)
- Concept 07: Handling User Input
- Concept 08: Getting User Data in Flask — Part 1
- Concept 09: Exercise: Getting User Data in Flask — Part 2
- Concept 10: Using AJAX to send data to flask
- Concept 11: Exercise or Demo: Using sessions in controllers
- Concept 12: Lesson Recap
- Concept 13: Glossary
- Concept 14: Further Reading and Learning
-
Lesson 08: Build a CRUD App with SQLAlchemy ORM - Part 2
Finish developing our To-Do app with update and delete functionality. Model relationships with To-Do lists.
- Concept 01: Introduction
- Concept 02: Exercise: Updating a Todo Item: Part I
- Concept 03: Updating a Todo Item: Part II
- Concept 04: Exercise: Deleting a Todo item
- Concept 05: Solution: Deleting a Todo item-
- Concept 06: Intro: Modeling Relationships
- Concept 07: Review: Relationships & Joins
- Concept 08: db.relationship
- Concept 09: Configuring Relationships
- Concept 10: Exercise: Foreign Key Constraint Setup
- Concept 11: Exercise: One-to-Many Relationship Setup
- Concept 12: Practice - Modeling Relationships
- Concept 13: Exercise: CRUD on a List of To-Dos part 1
- Concept 14: Exercise CRUD part 1 Solution
- Concept 15: Exercise: CRUD on a List of To-Dos part 2
- Concept 16: Exercise CRUD part 2 Solution
- Concept 17: Many-To-Many Relationships: Part I
- Concept 18: Exercise and Demo Practice: Many-To-Many Relationships: Part II
- Concept 19: Recap
-
Lesson 09: Project: Fyyur
In this project, you'll demonstrate your new SQL and data modeling skills by creating a site to help coordinate bookings between artists and venues.
-
Part 03 : API Development and Documentation
In this project, you will use the skills you’ve developed to build a Trivia API. The goal of this project is to use APIs to control and manage a web application using existing data models. You’ll be given a set of data models and the application front end. Your task will be to implement the API in Flask to make the Trivia game functional.
-
Module 01: API Development and Documentation
-
Lesson 01: Introduction to APIs
In this lesson, you'll learn what APIs are, how they're implemented, and why they're important. We'll also dive into the concepts of Internet Protocols and REST.
-
Lesson 02: HTTP and Flask Basics
In this lesson, you'll learn about HTTP—including methods, requests, responses and status codes— as well as how to set up a Flask app, and implement and test endpoints using Curl.
-
Lesson 03: Endpoints and Payloads
In this lesson, you'll learn about how Flask is extensible in itself to handle different kinds of methods, more complex endpoints, and to return formatted data to the client.
- Concept 01: Overview
- Concept 02: Organizing API endpoints
- Concept 03: CORS
- Concept 04: Flask-CORS
- Concept 05: Implementing Flask-CORS
- Concept 06: Flask - Route Decorator and Pagination
- Concept 07: Implementing Pagination
- Concept 08: Exercise: Requests
- Concept 09: Exercise Solution: Requests
- Concept 10: Quiz
- Concept 11: Flask Error Handling
- Concept 12: Exercise: Errors
- Concept 13: Solution: Errors
- Concept 14: Review
-
Lesson 04: API Testing
This lesson teaches students the benefits and purposes of testing an API, Test-Driven Development for APIs and implementing the tests using unittest.
-
Lesson 05: API Documentation
To round out the course, students will consider and write API documentation and project documentation so their projects can be hosted, shared, and used by other developers with clarity.
-
Lesson 06: Project: Trivia API
In this project, you'll use your new API and API documentation skills to build a trivia API.
-
Part 04 : Identity Access Management
In this part, you will build the backend for a coffee shop application. You’ll add user accounts and authentication to your application and use role-based access management strategies to control different types of user behavior in the app.
-
Module 01: Identity and Access Management
-
Lesson 01: Foundation
Set the groundwork for understanding information security and refresh your understanding of the technologies used in future lessons.
-
Lesson 02: Identity and Authentication
Explore frequently used methods of identifying who is making requests on web systems. Implement modern software patterns to accomplish this goal across the stack.
- Concept 01: Lesson Intro
- Concept 02: Common Authentication Methods
- Concept 03: Alternative Authentication Methods
- Concept 04: Third-Party Auth Systems
- Concept 05: Implementing Auth0
- Concept 06: JWT - JSON Web Tokens
- Concept 07: JWT - Datastructure
- Concept 08: JWT - Validation
- Concept 09: Practice - Generating and Verifying JWTs
- Concept 10: Practice - Validating Auth0 Tokens
- Concept 11: Local Storage
- Concept 12: Storing JWTs
- Concept 13: Sending Tokens
- Concept 14: Practice - Sending Tokens
- Concept 15: Practice - Applying Skills in Flask
- Concept 16: Recap
-
Lesson 03: Passwords
Understand and overcome common pitfalls of the ubiquitous password authentication design pattern.
- Concept 01: Lesson Intro
- Concept 02: Problems with Plain Text
- Concept 03: Problems - Brute Force Attacks
- Concept 04: Practice - Brute Force
- Concept 05: Problems - Data Handling and Logging
- Concept 06: Introduction to Encryption
- Concept 07: Using Encryption for User Tables
- Concept 08: Practice - Using Cryptography
- Concept 09: Asymmetric Encryption
- Concept 10: Hashing
- Concept 11: Practice - Rainbow Tables
- Concept 12: Hashing with Salts
- Concept 13: Practice - Salted, Hashed Passwords
- Concept 14: Recap
-
Lesson 04: Access and Authorization
Limit access to specific resources or actions by restricting requests only to authorized request to particular users and groups of users. Implement role-based access controls (RBAC) across the stack.
-
Lesson 05: Thinking Adversarially
Stay one step ahead of attackers by implementing a secure development process and knowing how to keep informed on the cutting edge of security research.
-
Lesson 06: Project: Coffee Shop Full Stack
In this project, you'll demonstrate your new authentication and authorization skills by creating a full-stack application for a coffee shop menu.
-
Part 05 : Server Deployment and Containerization
Develop an understanding of containerized environments, use Docker to share and store containers, and deploy a Docker
container to AWS Elastic Kubernetes Service using the CI/CD pipeline.
-
Module 01: Server Deployment, Containerization and Testing
-
Lesson 01: Introduction
Welcome to the Server Deployment, Containerization, and Testing course!
-
Lesson 02: Containers
An introduction to containers and Docker. In this lesson, you will install Docker locally, define a container using a Dockerfile, download and launch a Docker container, and store and share it.
-
Lesson 03: AWS and Kubernetes
Introduce AWS services, create resources with console and CLI, explain container orchestration and Kubernetes, create EKS Cluster with console and Eksctl, and manage Kubernetes with Kubectl.
- Concept 01: Intro and Overview
- Concept 02: Motivation
- Concept 03: Cloud Computing Overview
- Concept 04: Course - AWS Sign In and Costs
- Concept 05: S3 - Create a Bucket
- Concept 06: Elastic Cloud Compute (EC2)
- Concept 07: EC2 Demo
- Concept 08: IAM service
- Concept 09: Exercise - IAM
- Concept 10: AWS CLI
- Concept 11: AWS - Install and Configure CLI
- Concept 12: Exercise - Create S3 Bucket - CLI
- Concept 13: Kubernetes
- Concept 14: Kubernetes Concepts
- Concept 15: Kubernetes Components
- Concept 16: EKS: Kubernetes on AWS
- Concept 17: Exercise - Creating an EKS Cluster - Web console
- Concept 18: Installing eksctl
- Concept 19: Installing kubectl
- Concept 20: Exercise - Creating an EKS Cluster - CLI
-
Lesson 04: Deployment using CI/CD
Deploy app to EKS, create AWS resources with Cloudformation YAML, and set up end-to-end CI/CD pipeline with AWS CodePipeline and CodeBuild.
- Concept 01: Exercise - Deploy a Flask Application - Manually
- Concept 02: AWS - CloudFormation
- Concept 03: AWS - Template sections
- Concept 04: CloudFormation Exercise I - Create a VPC
- Concept 05: CloudFormation Exercise II - Create an EC2 instance
- Concept 06: CodePipeline
- Concept 07: CodeBuild
- Concept 08: CloudFormation Exercise III - Create a Pipeline
- Concept 09: Final Pipeline - Part 1 - Create an IAM Role for CodeBuild
- Concept 10: Final Pipeline - Part 2 - Authorize CodeBuild using EKS RBAC
- Concept 11: Final Pipeline - Part 3 - Deploy to EKS cluster
- Concept 12: Summary
-
Lesson 05: Deploy Your Flask App to Kubernetes Using EKS
In this project, learners will create a container for your Flask web app using Docker and deploy the
container to a Kubernetes cluster using Amazon EKS.Project Description - Deploy Your Flask App to Kubernetes Using EKS
Project Rubric - Deploy Your Flask App to Kubernetes Using EKS
- Concept 01: Project Overview
- Concept 02: Prerequisites and App Overview
- Concept 03: I.a. Running the App Locally
- Concept 04: I.b. Containerizing and Running Locally
- Concept 05: II.a. Overview of the CD Pipeline
- Concept 06: II.b. Create an EKS Cluster and IAM Role
- Concept 07: II.c. Deployment to Kubernetes using CodePipeline and CodeBuild
- Concept 08: II.d. Adding Tests to the Build
- Concept 09: Outro
-
Part 06 : Full Stack Capstone
You will now combine all of the new skills you’ve learned and developed in this course to construct a database-backed web API with user access control. You will choose what app to build and then you’ll design and build out all of the API endpoints needed for the application and properly secure them for use in any front end application (web or mobile).
-
Module 01: Capstone Project
-
Lesson 01: Capstone Prep and Deployment Options
In this lesson you’ll be introduced to the Capstone project. You'll learn how to deploy your API to Heroku and the Render Cloud Platforms.
- Concept 01: Capstone Introduction
- Concept 02: Local run
- Concept 03: Intro to Heroku
- Concept 04: [Heroku Option] Deployment Configuration
- Concept 05: [Heroku Option] Database Migrations
- Concept 06: [Heroku Option] Deployment
- Concept 07: Intro to Render Cloud Platform
- Concept 08: [Render Option] Set up Database Service
- Concept 09: [Render Option] Deployment
-
Part 07 (Career): Career Services
-
Module 01: Career Services
-
Lesson 01: 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
-
Lesson 02: 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
-