Docker

Docker is a centralized platform for packaging, deploying, and running applications. Before Docker, many users face the problem that a particular code is running in the developer's system but not in the user's system. So, the main reason to develop docker is to help developers to develop applications easily, ship them into containers, and can be deployed anywhere

What is Docker? Docker is an open-source centralized platform designed to create, deploy, and run applications. Docker uses container on the host's operating system to run applications. It allows applications to use the same Linux kernel as a system on the host computer, rather than creating a whole virtual operating system. Containers ensure that our application works in any environment like development, test, or production.

Docker includes components such as Docker client, Docker server, Docker machine, Docker hub, Docker composes, etc.

Let's understand the Docker containers and virtual machine.

Docker Containers
Docker containers are the lightweight alternatives of the virtual machine. It allows developers to package up the application with all its libraries and dependencies, and ship it as a single package. The advantage of using a docker container is that you don't need to allocate any RAM and disk space for the applications. It automatically generates storage and space according to the application requirement.

Virtual Machine
A virtual machine is a software that allows us to install and use other operating systems (Windows, Linux, and Debian) simultaneously on our machine. The operating system in which virtual machine runs are called virtualized operating systems. These virtualized operating systems can run programs and preforms tasks that we perform in a real operating system.

Containers Vs. Virtual Machine

Containers	Virtual Machine
Integration in a container is faster and cheap.	Integration in virtual is slow and costly.
No wastage of memory.	Wastage of memory.
It uses the same kernel, but different distribution.	It uses multiple independent operating systems.

Why Docker?
Docker is designed to benefit both the Developer and System Administrator. There are the following reasons to use Docker -

Docker allows us to easily install and run software without worrying about setup or dependencies.
Developers use Docker to eliminate machine problems, i.e. "but code is worked on my laptop." when working on code together with co-workers.
Operators use Docker to run and manage apps in isolated containers for better compute density.
Enterprises use Docker to securely built agile software delivery pipelines to ship new application features faster and more securely.
Since docker is not only used for the deployment, but it is also a great platform for development, that's why we can efficiently increase our customer's satisfaction.

Advantages of Docker
There are the following advantages of Docker -

It runs the container in seconds instead of minutes.
It uses less memory.
It provides lightweight virtualization.
It does not a require full operating system to run applications.
It uses application dependencies to reduce the risk.
Docker allows you to use a remote repository to share your container with others.
It provides continuous deployment and testing environment.

Disadvantages of Docker
There are the following disadvantages of Docker -

It increases complexity due to an additional layer.
In Docker, it is difficult to manage large amount of containers.
Some features such as container self -registration, containers self-inspects, copying files form host to the container, and more are missing in the Docker.
Docker is not a good solution for applications that require rich graphical interface.
Docker provides cross-platform compatibility means if an application is designed to run in a Docker container on Windows, then it can't run on Linux or vice versa.

Docker Engine
It is a client server application that contains the following major components.
A server which is a type of long-running program called a daemon process.
The REST API is used to specify interfaces that programs can use to talk to the daemon and instruct it what to do.
A command line interface client.

check if Git version

                     
                        git --version

Configure Git

Note: Use global to set the username and e-mail for every repository on your computer.

If you want to set the username/e-mail for just the current repo, you can remove global

                 
                git config --global user.name "sohammanjrekar"

                 
                git config --global user.email "mrsohammanjrekar@gmail.com"

Creating Git Folder

Creating Git Folder

mkdir makes a new directory.

cd changes the current working directory.

Note: If you already have a folder/directory you would like to use for Git:

Navigate to it in command line, or open it in your file explorer, right-click and select "Git Bash here"
```
    
        mkdir myproject
```
```
    
        cd myproject
```
Initialize Git

Initialize Git

Once you have navigated to the correct folder, you can initialize Git on that folder

In Java, there are different types of variables, for example:

Note: Git now knows that it should watch the folder you initiated it on. Git creates a hidden folder to keep track of changes.
```
    
        git init 
```

Git Adding New Files

Files in your Git repository folder can be in one of 2 states:

Tracked - files that Git knows about and are added to the repository

Untracked - files that are in your working directory, but not added to the repository

When you first add files to an empty repository, they are all untracked. To get Git to track them, you need to stage them, or add them to the staging environment.

Note: Short status flags are:
?? - Untracked files
A - Files added to stage
M - Modified files
D - Deleted files

ls

                                
                                    git status

                                
                                    git status --short

Git Adding in Staging Environment

One of the core functions of Git is the concepts of the Staging Environment, and the Commit.

As you are working, you may be adding, editing and removing files. But whenever you hit a milestone or finish a part of the work, you should add the files to a Staging Environment.

Staged files are files that are ready to be committed to the repository you are working on. You will learn more about commit shortly.

                                
                                    git add index.html

                                
                                    git add --all

Git Commit

Git Commit

Since we have finished our work, we are ready move from stage to commit for our repo.

Adding commits keep track of our progress and changes as we work. Git considers each commit change point or "save point". It is a point in the project you can go back to if you find a bug, or want to make a change.

When we commit, we should always include a message.

By adding clear messages to each commit, it is easy for yourself (and others) to see what has changed and when.

The commit command performs a commit, and the -m "message" adds a message.

Sometimes, when you make small changes, using the staging environment seems like a waste of time. It is possible to commit changes directly, skipping the staging environment. The -a option will automatically stage every changed, already tracked file.

Warning: Skipping the Staging Environment is not generally recommended. Skipping the stage step can sometimes make you include unwanted changes.
git commit -m "update"
git commit -a -m "Updated"
git log

Git Help

If you are having trouble remembering commands or options for commands, you can use Git help.

There are a couple of different ways you can use the help command in command line:

git command -help - See all the available options for the specific command

git help --all - See all possible commands

                                        
                                            git commit --help

Note: If you find yourself stuck in the list view, SHIFT + G to jump the end of the list, then q to exit the view.

                                        
                                    
                                        git help --all

Git Branch

Git Branch

In Git, a branch is a new/separate version of the main repository.

Let's say you have a large project, and you need to update the design on it.

How would that work without and with Git:

Without Git:
Make copies of all the relevant files to avoid impacting the live version

Start working with the design and find that code depend on code in other files, that also need to be changed!

Make copies of the dependant files as well. Making sure that every file dependency references the correct file name

EMERGENCY! There is an unrelated error somewhere else in the project that needs to be fixed ASAP!

Save all your files, making a note of the names of the copies you were working on

Work on the unrelated error and update the code to fix it

Go back to the design, and finish the work there

Copy the code or rename the files, so the updated design is on the live version

(2 weeks later, you realize that the unrelated error was not fixed in the new design version because you copied the files before the fix)

With Git:
With a new branch called new-design, edit the code directly without impacting the main branch

EMERGENCY! There is an unrelated error somewhere else in the project that needs to be fixed ASAP!

Create a new branch from the main project called small-error-fix

Fix the unrelated error and merge the small-error-fix branch with the main branch

You go back to the new-design branch, and finish the work there

Merge the new-design branch with main (getting alerted to the small error fix that you were missing)

Branches allow you to work on different parts of a project without impacting the main branch. When the work is complete, a branch can be merged with the main project. You can even switch between branches and work on different projects without them interfering with each other. Branching in Git is very lightweight and fast!

Emergency Branch
Now imagine that we are not yet done with hello-world-images, but we need to fix an error on master.
I don't want to mess with master directly, and I do not want to mess with hello-world-images, since it is not done yet.
git branch hello
git branch
git checkout hello
git checkout -b emergency-fix

Git Branch Merge

The text-align-last property specifies how to align the last line of a text.

We divide modifiers into two groups:
1) Access Modifiers - controls the access level
2) Non-Access Modifiers - do not control access level, but provides other functionality

1) Access Modifiers
For classes, you can use either public or default

                                    
                                        git merge emergency-fix

                                    
                                        git branch -d emergency-fix

Push Local Repository to GitHub

git remote add origin URL specifies that you are adding a remote repository, with the specified URL, as an origin to your local Git repo.

                            
                                git remote add origin https://github.com/w3schools-test/hello-world.git

                                
                                    git push --set-upstream origin master

Pulling to Keep up-to-date with Changes

When working as a team on a project, it is important that everyone stays up to date.

Any time you start working on a project, you should get the most recent changes to your local copy.

With Git, you can do that with pull.

pull is a combination of 2 different commands:
fetch
merge

Git Fetch
fetch gets all the change history of a tracked branch/repo.

Git Pull
pull is a combination of fetch and merge. It is used to pull all changes from a remote repository into the branch you are working on.

                                            
                                                git fetch origin

                                            
                                                git pull origin

Push Changes to GitHub

                                            
                                                git push origin

Push Local Repository to GitHub Pages

                                                                                    
                                                git remote add gh-page https://github.com/w3schools-test/w3schools-test.github.io.git

                                                                                        
                                                    git push gh-page master

Git Clone from GitHub

Note: According to Git naming conventions, it is recommended to name your own repository origin, and the one you forked for upstream Now we have 2 remotes:

origin - our own fork, where we have read and write access
upstream - the original, where we have read-only access

                                
                                    git clone https://github.com/w3schools-test/w3schools-test.github.io.git

we have a full copy of a repository, whose origin we are not allowed to make changes to.

                                
                                    git remote -v

                                
                                    git remote add origin https://github.com/kaijim/w3schools-test.github.io.git

Git Ignore and .gitignore

Git Ignore
When sharing your code with others, there are often files or parts of your project, you do not want to share.

Examples
log files
temporary files
hidden files
personal files
etc.

Git can specify which files or parts of your project should be ignored by Git using a .gitignore file.
Git will not track files and folders specified in .gitignore. However, the .gitignore file itself IS tracked by Git.
Note: In this case, we use a single .gitignore which applies to the entire repository.

It is also possible to have additional .gitignore files in subdirectories. These only apply to files or folders within that directory. Rules for .gitignore Here are the general rules for matching patterns in .gitignore files:

Pattern	Explanation/Matches	Examples
	Blank lines are ignored
# text comment	Lines starting with # are ignored
name	All name files, name folders, and files and folders in any name folder	/name.log /name/file.txt /lib/name.log
name/	Ending with / specifies the pattern is for a folder. Matches all files and folders in any name folder	/name/file.txt /name/log/name.log no match: /name.log
name.file	All files with the name.file	/name.file /lib/name.file
/name.file	Starting with / specifies the pattern matches only files in the root folder	/name.file no match: /lib/name.file
lib/name.file	Patterns specifiing files in specific folders are always realative to root (even if you do not start with / )	/lib/name.file no match: name.file /test/lib/name.file
**/lib/name.file	Starting with ** before / specifies that it matches any folder in the repository. Not just on root.	/lib/name.file /test/lib/name.file
**/name	All name folders, and files and folders in any name folder	/name/log.file /lib/name/log.file /name/lib/log.file
/lib/**/name	All name folders, and files and folders in any name folder within the lib folder.	/lib/name/log.file /lib/test/name/log.file /lib/test/ver1/name/log.file no match: /name/log.file
*.file	All files withe .file extention	/name.file /lib/name.file
*name/	All folders ending with name	/lastname/log.file /firstname/log.file
name?.file	? matches a single non-specific character	/names.file /name1.file no match: /names1.file
name[a-z].file	[range] matches a single character in the specified range (in this case a character in the range of a-z, and also be numberic.)	/names.file /nameb.file no match: /name1.file
name[abc].file	[set] matches a single character in the specified set of characters (in this case either a, b, or c)	/namea.file /nameb.file no match: /names.file
name[!abc].file	[!set] matches a single character, except the ones spesified in the set of characters (in this case a, b, or c)	/names.file /namex.file no match: /namesb.file
*.file	All files withe .file extention	/name.file /lib/name.file
name/ !name/secret.log	! specifies a negation or exception. Matches all files and folders in any name folder, except name/secret.log	/name/file.txt /name/log/name.log no match: /name/secret.log
.file !name*.file	! specifies a negation or exception. All files withe .file extention, except name.file	/log.file /lastname.file no match: /name.file
.file !name/.file junk.*	Adding new patterns after a negation will re-ignore a previous negated file All files withe .file extention, except the ones in name folder. Unless the file name is junk	/log.file /name/log.file no match: /name/junk.file

                    
                        touch .gitignore

Git Security SSH

Git Security SSH

Git Security Up to this point, we have used HTTPS to connect to our remote repository. HTTPS will usually work just fine, but you should use SSH if you work with unsecured networks.

And sometimes, a project will require that you use SSH. What is SSH SSH is a secure shell network protocol that is used for network management, remote file transfer, and remote system access. SSH uses a pair of SSH keys to establish an authenticated and encrypted secure network protocol.

It allows for secure remote communication on unsecured open networks.

SSH keys are used to initiate a secure "handshake". When generating a set of keys, you will generate a "public" and "private" key.

The "public" key is the one you share with the remote party. Think of this more as the lock.

The "private" key is the one you keep for yourself in a secure place. Think of this as the key to the lock.

SSH keys are generated through a security algorithm. It is all very complicated, but it uses prime numbers, and large random numbers to make the public and private key. It is created so that the public key can be derived from the private key, but not the other way around.
```
                    
                        ssh-keygen -t rsa -b 4096 -C "test@w3schools.com"
                         
                    
```
```
                        
                            ssh-add /Users/user/.ssh/id_rsa
                             
                        
```

Test SSH Connection to GitHub

                    
                        ssh -T git@github.com

                        
                            git remote add ssh-origin git@github.com:w3schools-test/hello-world.git

change a remote origin from HTTPS to SSH

                    
                        git remote set-url origin git@github.com:w3schools-test/hello-world.git

Git Revert Find Commit in Log

Git Revert Find Commit in Log

First thing, we need to find the point we want to return to. To do that, we need to go through the log.

To avoid the very long log list, we are going to use the --oneline option, which gives just one line per commit showing:

The first seven characters of the commit hash the commit message

We want to revert to the previous commit: 52418f7 (HEAD -> master) Just a regular update, definitely no accidents here..., and we see that it is the latest commit.

Git Revert HEAD
We revert the latest commit using git revert HEAD (revert the latest change, and then commit), adding the option --no-edit to skip the commit message editor
git log --oneline
git revert HEAD --no-edit
Git Reset

Git Reset

reset is the command we use when we want to move the repository back to a previous commit, discarding any changes made after that commit.

Git Reset Find Commit in Log
First thing, we need to find the point we want to return to. To do that, we need to go through the log.
To avoid the very long log list, we are going to use the --oneline option, which gives just one line per commit showing:

The first seven characters of the commit hash - this is what we need to refer to in our reset command. the commit message
```
                                
                                    git reset 9a9add8
                                
                                
```
Git Amend

Git Amend

reset is the command we use when we want to move the repository back to a previous commit, discardcommit --amend is used to modify the most recent commit. It combines changes in the staging environment with the latest commit, and creates a new commit. This new commit replaces the latest commit entirely.
```
                                
                                    git commit --amend -m "Added lines to README.md"
                                
                                
```

Docker

Git

Configure Git

Creating Git Folder

Initialize Git

Git Adding New Files

Git Adding in Staging Environment

Git Commit

Git Help

Note: If you find yourself stuck in the list view, SHIFT + G to jump the end of the list, then q to exit the view.

Git Branch

Git Branch Merge

Encapsulation

JPulling to Keep up-to-date with Changes

JPulling to Keep up-to-date with Changes

we have a full copy of a repository, whose origin we are not allowed to make changes to.

Git Ignore and .gitignore

Git Security SSH

Git Revert Find Commit in Log

Git Reset

Git Amend

Docker

Git

Configure Git

Creating Git Folder

Initialize Git

Git Adding New Files

list the files in the directory

check the Git status

check the Git Short status

Git Adding in Staging Environment

git add index.html

add all file in Staging Environment

Git Commit

stage to commit

Git Commit without Stage

Git Commit Log

Git Help

Git -help See Options

Git help See All Possible Commands

Note: If you find yourself stuck in the list view, SHIFT + G to jump the end of the list, then q to exit the view.

Git Branch

create a new branch

check list of branches

move our current workspace to the new branch

create a new branch to deal with the emergency

Git Branch Merge

merge the current branch (master) with emergency-fix

Deleted branch

Encapsulation

JPulling to Keep up-to-date with Changes

Git Fetch

Git Pull

JPulling to Keep up-to-date with Changes

clone the repository

Configuring Remotes

we have a full copy of a repository, whose origin we are not allowed to make changes to.

fork own file

Git Ignore and .gitignore

Git Security SSH

Git Revert Find Commit in Log

find the point we want to revert

Git Revert HEAD

Git Reset

Git Amend