Full Stack for Front End Engineers [2017, ENG]

Содержание

Table of Contents
Full Stack for Frontend Engineers
Introduction
00:00:00 - 00:06:46
Introduction
Jem Young introduces his course, Full Stack for Engineers, and provides an agenda for the first part of course.. Demonstrating how the Internet works from server to your browser, Jem covers the fundamentals for building on the web.
Domains
Inroducing domains
00:06:47 - 00:08:12
Inroducing domains
Jem talks about the basics of domains and how they relate to IP addresses.
DNS
00:08:13 - 00:10:57
DNS
Talking about how IP address maps to domain names, Jem reviews the importance of DNS. - https://en.wikipedia.org/wiki/2016_Dyn_cyberattack
Exercise 1: Ping
00:10:58 - 00:12:51
Exercise 1: Ping
Jem covers ping, a network tool for testing if a domain name is reachable. Then going through several domains, Jem demonstrates how to use ping command and read the results.
DNS Caches
00:12:52 - 00:15:41
DNS Caches
Jem reviews the concept of DNS caches and the different types of DNS caches that help speed looking up of domains.
Security
00:15:42 - 00:17:25
Security
Talking about the importance of Internet security, Jem asks to be mindful of your internet practices as people are always trying to break into your server.
Cache Poisoning
00:17:26 - 00:19:48
Cache Poisoning
Jem describes a potential security problem with cache poisoning, also known as DNS spoofing. When false DNS information introduced, a hacker could divert your site's traffic to their server.
Exercise 2: Traceroute
00:19:49 - 00:23:14
Exercise 2: Traceroute
Jem shows traceroute, a network tool for illustrating the path to a server as well as the time it takes to connect. Using Netflix.com as an example, Jem reviews the output from a traceroute to show how a browser gets to the domain.
Vim
Exercise 3: Introducing Vim
00:23:15 - 00:26:08
Exercise 3: Introducing Vim
Giving an overview of the UNIX text editor, Jem discusses the importance for engineers to learning Vim. Afterwards, Jem introduces a VIM ercise. In this exercise, students open the Vim editor in their terminal application. Using his computer, Jem shows how to initiate the Vim editor. - http://www.vim.org/about.php
Exercise 4: Vim modes
00:26:09 - 00:30:53
Exercise 4: Vim modes
Jem reviews three modes to operate Vim: command, insert, and the last line. At the start, Vim is in command mode. In this exercise, students open the Vim editor and change into the software's different command modes. Jem reviews Vim's inserting mode and shows how to write code within the editor. - https://vimgifs.com/i/
VIM command mode
00:30:54 - 00:33:39
VIM command mode
Manipulating a file with Vim, Jem demonstrates common tasks available in command mode. - http://vimgifs.com/u/
Exercise 5: Vim command mode
00:33:40 - 00:38:18
Exercise 5: Vim command mode
Jem sets up an exercise for using the Vim command mode. Then Jem demonstrates some of the more standard Vim command mode functions. - - http://vim.wikia.com/wiki/Copy,_cut_and_paste - https://linuxmoz.com/vi-commands-cheat-sheet/
Editing and Saving in Vim
00:38:19 - 00:43:00
Editing and Saving in Vim
Jem covers editing and saving commands in Vim. - https://9to5mac.com/2016/10/25/remap-escape-key-action-macbook-pro-macos-sierra-1...1-modifier-keys/
Exercise 6: Editing and Saving in Vim
00:43:01 - 00:46:51
Exercise 6: Editing and Saving in Vim
To help learn Vim through repetition, Jem sets up an exercise for writing out Vim commands in the Vim editor. Then Jem answers student questions about editing and saving with Vim.
Servers
Exercise 7: Introducing Servers
00:46:52 - 00:51:46
Exercise 7: Introducing Servers
Jem introduces Internet servers. Then Jem demonstrates logging into a server with secure remote login application, secure shell (SSH). Walking through logging into a server, Jem shows how to use SSH.
SSH
00:51:47 - 00:56:42
SSH
By talking about the problems of simple passwords, Jem further explores the concept of SSH and public key authentication.
Exercise 8: Creating an SSH Key
00:56:43 - 01:08:55
Exercise 8: Creating an SSH Key
Jem introduces an exercise to make an SSH key to log into a server securely. Jem walks through the steps to generate a private and public SSH keys.
Setting up a VPS
VPS & Cloud Computing
01:08:56 - 01:11:26
VPS & Cloud Computing
Reviewing the types of servers, dedicated servers, and VPS, Jem introduces cloud computing.
Exercise 9: Buy a VPS
01:11:27 - 01:23:08
Exercise 9: Buy a VPS
In this exercise, students buy space on a VPS. Jem demonstrates differences between AWS and Digital Ocean. Using the public key generated earlier in the course, Jem walks through steps to buy a VPS through Digital Ocean. - - http://digitalocean.com/ - https://education.github.com/pack/join
Exercise 10: Log onto your own server
01:23:09 - 01:26:53
Exercise 10: Log onto your own server
In this exercise, Jem and students log into the server that they recently made.
Exercise 11: top
01:26:54 - 01:29:19
Exercise 11: top
In this exercise, students use a task manager program to create a list of running processes on a server. Then Jem reviews top and also installs htop, an alternative to top with a color interface.
Exercise 12: Setting up your server
01:29:20 - 01:42:01
Exercise 12: Setting up your server
In this exercise, you will work on upgrading software and adding a new user to the server to avoid using root login. Answering student questions, Jem works through the steps to update the server. To make sure no one else uses root, Jem also adds new users to access the server and adds them to a sudo group.
Logging in with SSH
01:42:02 - 02:00:11
Logging in with SSH
Jem demonstrates how to assign SSH public key to a newly created server.
Disable root access
02:00:12 - 02:05:41
Disable root access
After reviewing the importance of disabling root access, Jem shows how to modify the SSH config file to block root access into the server.
Getting a Domain Name
Buying a domain
02:05:42 - 02:14:13
Buying a domain
To make our server easier to find on the web, an IP address should point to a domain name. Jem first illustrates how to purchase a domain name. - http://namecheap.com/
Associating the DNS
02:14:14 - 02:18:32
Associating the DNS
To connect a domain name to the new server, Jem demonstrates how to map an IP address to a domain name using A record.
Using CNAMEs
02:18:33 - 02:20:31
Using CNAMEs
If a project is hosted on Github, Jem indicates that a CNAME record can be used to associate a domain name for free hosting. - - https://support.dnsimple.com/articles/differences-between-a-cname-alias-url/ - https://support.dnsimple.com/articles/differences-between-a-cname-alias-url/ - http://keycode.info/ - https://github.com/wesbos/keycodes/blob/gh-pages/CNAME
Wrapping Up
02:20:32 - 02:23:44
Wrapping Up
Finishing associating a domain name with the IP address, Jem takes questions from students about IP address and the difference between A and CNAME records.
Setting Up the Server
Introducing Unix Operating Systems
02:23:45 - 02:28:57
Introducing Unix Operating Systems
Jem reviews the operating systems (OS) and why a UNIX-based OS such as Ubuntu is preferred.
Introducting Nginx
02:28:58 - 02:32:21
Introducting Nginx
Jem introduces Nginx, a web server that can be used as a reverse proxy. Unlike a proxy server, a reverse proxy accepts requests from external clients—such as browser requests for a web page—on behalf of servers.
Exercise 13: Nginx
02:32:22 - 02:35:30
Exercise 13: Nginx
In this exercise, students work on installing Nginx on your new server. Then Jem shows how to install Nginx on the new server.
Exercise 14: Nginx configuration
02:35:31 - 02:42:52
Exercise 14: Nginx configuration
With Nginx installed, you will look through the web server's default configuration file. Underscoring the progress of setting up a server to pointing to a web server with a new custom domain name, Jem walks through steps to display the Nginx default configuration
Installing Git, NodeJS, and NPM
02:42:53 - 02:45:22
Installing Git, NodeJS, and NPM
Jem installs Git, NodeJS, and NPM onto the new server.
Making a symbolic link
02:45:23 - 02:47:57
Making a symbolic link
Creating a symbolic link, Jem sets NodeJS to mean node on the server.
Creating a web directory
02:47:58 - 02:50:16
Creating a web directory
To place files for the web site, Jem shows how to create a web directory.
Changing permissions
02:50:17 - 02:53:01
Changing permissions
To keep from the repetitive usage of sudo when creating files, Jem uses the chown command to change folder and file permissions.
Cloning a Git repository
02:53:02 - 02:55:07
Cloning a Git repository
Jem clones a repository from GitHub onto his new server.
Rename directory and installing npm
02:55:08 - 02:57:58
Rename directory and installing npm
To make the project more friendly for development, Jem renames the "Dev-Ops-for-Frontend" directory to "app". Afterward, Jem installs npm in the app directory.
Starting the server
02:57:59 - 02:59:36
Starting the server
Jem starts the node server, which is serving off port 3001.
Modifying the Server
Changing server ports
02:59:37 - 03:08:09
Changing server ports
By modifying Nginx, Jem sends external browsing requests to the server to port 3001. Then within the app directory, students check out a branch of the repository and customize the HTML.
Deploying Code
Deploying Code & Introducing Gulp
03:08:10 - 03:09:36
Deploying Code & Introducing Gulp
Jem introduces the concept of deploying code by setting up Gulp and a deploy system. Then Jem talks about Gulp. A JavaScript task runner, Gulp is used to streamline the build systems in front-end web development.
Exercise 15: Creating Gulp tasks
03:09:37 - 03:14:10
Exercise 15: Creating Gulp tasks
In this exercise, students build a simple Gulp task to minify CSS. Jem walks through a solution to the steps to make a Gulp task.
Installing Gulp
03:14:11 - 03:21:40
Installing Gulp
Fixing NPM permissions, Jem installs Gulp globally on the server so that the task manager runs from the command line. - https://docs.npmjs.com/getting-started/fixing-npm-permissions
Keeping an app running
03:21:41 - 03:24:15
Keeping an app running
To keep from having to start and stop the web server repeatedly, Jem demonstrates a process manager called Forever that keeps the process running indefinitely.
Log Files
Log files
03:24:16 - 03:28:03
Log files
Jem sets up log files to track any potential errors Forever.
Exercise 16: Tailing a log file
03:28:04 - 03:33:49
Exercise 16: Tailing a log file
In order to monitor a server's log file to determine what is happening on the server in real-time, Jem sets up tail, a Unix program. Tail displays the end of a text file and updates the display if there is additional server activity. Jem demonstrates how to use tail to watch his server's log file.
Putting it all together
Exercise 17: Putting it all together
03:33:50 - 03:39:42
Exercise 17: Putting it all together
In this exercise, students work to combine Gulp and Forever into one command. Jem reviews the exercise solution by coding a deploy command and demonstrating it on his server.
Wrapping Up and Q&A
Course wrap-up
03:39:43 - 04:05:40
Course wrap-up
Jem reviews the steps students have gone through to create a server and launch a new web application. Answering student questions, Jem talks about the differences between HTTP and HTTP2 and benefits and constraints of HTTP2; how to associate a CSS file in the Node app; how to deploy a few or many servers from a laptop; how a server can host multiple domains on one Nginx setup; an overview of setting up HTTPS; how to backup private SSH keys; and whether GZIP, a file compression utility used for reducing the file size of web assets, can be used in tandem with HTTPS. - - https://github.com/glenux/polyssh - https://www.charlesproxy.com/ - http://www.fail2ban.org/wiki/index.php/Main_Page

Скриншоты