Three Steps To Install Angular

Step 1 - Install NodeJS

1. Follow the link - https://nodejs.org/en/download/
2. Download the node.js installer for Windows and install it.
3. Type the “npm -v” command to check the Node.js installation and version.

Step 2 - Install TypeScript

1. Open the link https://www.npmjs.com/package/typescript
2. Copy the above command “npm install -g typescript” and run it on command prompt.

Step 3 - Install Angular CLI
Open the link https://cli.angular.io/ and follow the instructions to install Angular CLI and to create your first  Angular app.

1. Type the command “npm install -g @angular/cli” on the command prompt and press enter to install Angular cli.
   
2. Type “ng new hello-world” and hit enter to create the Hello World app.
   Once you see the message “Project ‘hello-world’”  it means the app is created on the disk.
3. Finally, the "Hello World" Angular app is created; now type “ng serve -o”.
   

Now, open the browser and type http://localhost:4200  in the address bar and hit enter to run the Hello World Angular app in the browser.

Chocolatey software management automation for Windows

Why Chocolatey ?

Chocolatey is software management automation
Chocolatey works with over 20+ installer technologies for Windows, but it can manage things you would normally xcopy deploy (like runtime binaries and zip files). You can also work with registry settings or managing files and configurations, or any combination. Since it uses PowerShell, if you can dream it, you can do it with Chocolatey.
Chocolatey builds on technologies that are familiar:

• PowerShell
• Unattended installations

Chocolatey also integrates with infrastructure management tools (like Puppet, Chef or SCCM) and other remote administration tools

Installing Chocolatey

1. Chocolatey installs in seconds. You are just a few steps from running choco right now!
2. Paste the copied text into your shell and press Enter.
3. If you don't see any errors, you are ready to use Chocolatey! Type choco or choco -?

Install with cmd.exe
@"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))" && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin" 

Install with PowerShell.exe
Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

Upgrading Chocolatey
choco upgrade chocolatey

Upgrading all


choco upgrade all -y 

Chocolatey Community Maintained Package 
https://chocolatey.org/packages

 

BEST PRACTICES

This is where general Docker best practices and war stories go:

• Docker Documentation
• Docker Cheat Sheet
• Best practices for writing Dockerfiles
• Dockerfile Best Practices
• Dockerfile Best Practices 2
• 
  
• Building Good Docker images
• Write Excellent Dockerfiles
• 
  
• 15-docker-tips-in-5-minutes
• Everyday Hacks Docker
•  
• Docker Image Security Best Practices
• Docker Bench Security
• Docker Engine Security Cheat Sheet
• Docker Security Best Practices for Your Vessel And Container
•  
• Docker tips tricks and tutorials  

DOCKER CHEATSHEET

Docker Registries & Repositories
Login to a Registry
docker login
docker login localhost:8080
Logout from a Registry
docker logout
docker logout localhost:8080
Searching an Image
docker search nginx
docker search --filter stars=3 --no-trunc nginx
Pulling an Image
docker image pull nginx
docker image pull eon01/nginx localhost:5000/myadmin/nginx
Pushing an Image
docker image push eon01/nginx
docker image push eon01/nginx localhost:5000/myadmin/nginx

Running Containers
Create and Run a Simple Container

• Start an ubuntu:latest image
• Bind the port 80 from the CONTAINER to port 3000 on the HOST
• Mount the current directory to /data on the CONTAINER
• Note: on windows you have to change -v ${PWD}:/data to -v "C:\Data":/data

docker container run --name infinite -it -p 3000:80 -v ${PWD}:/data ubuntu:latest
Creating a Container
docker container create -t -i eon01/infinite --name infinite
Running a Container
docker container run -it --name infinite -d eon01/infinite
Renaming a Container
docker container rename infinite infinity
Removing a Container
docker container rm infinite
Updating a Container
docker container update --cpu-shares 512 -m 300M infinite

Starting & Stopping Containers
Starting
docker container start nginx
Stopping
docker container stop nginx
Restarting
docker container restart nginx
Pausing
docker container pause nginx
Unpausing
docker container unpause nginx
Blocking a Container
docker container wait nginx
Sending a SIGKILL
docker container kill nginx
Sending another signal
docker container kill -s HUP nginx
Connecting to an Existing Container
docker container attach nginx

Getting Information about Containers
Running Containers
docker container ls
docker container ls -a
Container Logs
docker logs infinite
Follow Container Logs
docker container logs infinite -f
Inspecting Containers
docker container inspect infinite
docker container inspect --format '{{ .NetworkSettings.IPAddress }}' $(docker ps -q)
Containers Events
docker system events infinite
Public Ports
docker container port infinite
Running Processes
docker container top infinite
Container Resource Usage
docker container stats infinite
Inspecting changes to files or directories on a container’s filesystem
docker container diff infinite

Manipulating Images
Listing Images
docker image ls
Building Images
docker build .
docker build github.com/creack/docker-firefox
docker build - < Dockerfile
docker build - < context.tar.gz
docker build -t eon/infinite .
docker build -f myOtherDockerfile .
curl example.com/remote/Dockerfile | docker build -f - .
Removing an Image
docker image rm nginx
Loading a Tarred Repository from a File
docker image load < ubuntu.tar.gz
docker image load --input ubuntu.tar
Save an Image to a Tar Archive
docker image save busybox > ubuntu.tar
Showing the History of an Image
docker image history
Creating an Image From a Container
docker container commit nginx
Tagging an Image
docker image tag nginx eon01/nginx
Pushing an Image
docker image push eon01/nginx

Networking
Creating Networks

• docker network create -d overlay MyOverlayNetwork
• docker network create -d bridge MyBridgeNetwork
• docker network create -d overlay \ --subnet=192.168.0.0/16 \ --subnet=192.170.0.0/16 \ --gateway=192.168.0.100 \ --gateway=192.170.0.100 \ --ip-range=192.168.1.0/24 \ --aux-address="my-router=192.168.1.5" --aux-address="my-switch=192.168.1.6" \ --aux-address="my-printer=192.170.1.5" --aux-address="my-nas=192.170.1.6" \ MyOverlayNetwork

Removing a Network
docker network rm MyOverlayNetwork
Listing Networks
docker network ls
Getting Information About a Network
docker network inspect MyOverlayNetwork
Connecting a Running Container to a Network
docker network connect MyOverlayNetwork nginx
Connecting a Container to a Network When it Starts
docker container run -it -d --network=MyOverlayNetwork nginx
Disconnecting a Container from a Network
docker network disconnect MyOverlayNetwork nginx
Exposing Ports
Using Dockerfile, you can expose a port on the container using:
EXPOSE
You can also map the container port to a host port using:
e.g.
docker run -p $HOST_PORT:$CONTAINER_PORT --name infinite -t infinite

Security
Guidelines for building secure Docker images

• Prefer minimal base images
• Dedicated user on the image as the least privileged user
• Sign and verify images to mitigate MITM attacks
• Find, fix and monitor for open source vulnerabilities
• Don’t leak sensitive information to docker images
• Use fixed tags for immutability
• Use COPY instead of ADD
• Use labels for metadata
• Use multi-stage builds for small secure images
• Use a linter

More detailed information on Snyk's 10 Docker Image Security Best Practices blog

Cleaning Docker
Removing a Running Container
docker container rm nginx
Removing a Container and its Volume
docker container rm -v nginx
Removing all Exited Containers
docker container rm $(docker container ls -a -f status=exited -q)
Removing All Stopped Containers
docker container rm `docker container ls -a -q`
Removing a Docker Image
docker image rm nginx
Removing Dangling Images
docker image rm $(docker image ls -f dangling=true -q)
Removing all Images
docker image rm $(docker image ls -a -q)
Removing all untagged images
docker image rm -f $(docker image ls | grep "^" | awk "{print $3}")
Stopping & Removing all Containers
docker container stop $(docker container ls -a -q) && docker container rm $(docker container ls -a -q)
Removing Dangling Volumes
docker volume rm $(docker volume ls -f dangling=true -q)
Removing all unused (containers, images, networks and volumes)
docker system prune -f
Clean all
docker system prune -a

Docker Swarm
Initializing the Swarm
docker swarm init --advertise-addr 192.168.10.1
Getting a Worker to Join the Swarm
docker swarm join-token worker
Getting a Manager to Join the Swarm
docker swarm join-token manager
Listing Services
docker service ls
Listing nodes
docker node ls
Creating a Service
docker service create --name vote -p 8080:80 instavote/vote
Listing Swarm Tasks
docker service ps
Scaling a Service
docker service scale vote=3
Updating a Service
docker service update --image instavote/vote:movies vote
docker service update --force --update-parallelism 1 --update-delay 30s nginx
docker service update --update-parallelism 5--update-delay 2s --image instavote/vote:indent vote
docker service update --limit-cpu 2 nginx
docker service update --replicas=5 nginx
Notes:
This work was first published in Painless Docker Course

Dockerfile Instructions

FROM Usage: FROM FROM : FROM @ Information: FROM must be the first non-comment instruction in the Dockerfile. FROM can appear multiple times within a single Dockerfile in order to create multiple images. Simply make a note of the last image ID output by the commit before each new FROM command. The tag or digest values are optional. If you omit either of them, the builder assumes a latest by default. The builder returns an error if it cannot match the tag value. Reference - Best Practices

MAINTAINER Usage: MAINTAINER The MAINTAINER instruction allows you to set the Author field of the generated images. Reference

RUN Usage: RUN (shell form, the command is run in a shell, which by default is /bin/sh -c on Linux or cmd /S /C on Windows) RUN ["", "", ""] (exec form) Information: The exec form makes it possible to avoid shell string munging, and to RUN commands using a base image that does not contain the specified shell executable. The default shell for the shell form can be changed using the SHELL command. Normal shell processing does not occur when using the exec form. For example, RUN ["echo", "$HOME"] will not do variable substitution on $HOME. Reference - Best Practices

CMD Usage: CMD ["","",""] (exec form, this is the preferred form) CMD ["",""] (as default parameters to ENTRYPOINT) CMD (shell form) Information: The main purpose of a CMD is to provide defaults for an executing container. These defaults can include an executable, or they can omit the executable, in which case you must specify an ENTRYPOINT instruction as well. There can only be one CMD instruction in a Dockerfile. If you list more than one CMD then only the last CMD will take effect. If CMD is used to provide default arguments for the ENTRYPOINT instruction, both the CMD and ENTRYPOINT instructions should be specified with the JSON array format. If the user specifies arguments to docker run then they will override the default specified in CMD. Normal shell processing does not occur when using the exec form. For example, CMD ["echo", "$HOME"] will not do variable substitution on $HOME. Reference - Best Practices

LABEL Usage: LABEL = [= ...] Information: The LABEL instruction adds metadata to an image. To include spaces within a LABEL value, use quotes and backslashes as you would in command-line parsing. Labels are additive including LABELs in FROM images. If Docker encounters a label/key that already exists, the new value overrides any previous labels with identical keys. To view an image’s labels, use the docker inspect command. They will be under the "Labels" JSON attribute. Reference - Best Practices

EXPOSE Usage: EXPOSE [ ...] Information: Informs Docker that the container listens on the specified network port(s) at runtime. EXPOSE does not make the ports of the container accessible to the host. Reference - Best Practices

ENV Usage: ENV ENV = [= ...] Information: The ENV instruction sets the environment variable to the value . The value will be in the environment of all “descendant” Dockerfile commands and can be replaced inline as well. The environment variables set using ENV will persist when a container is run from the resulting image. The first form will set a single variable to a value with the entire string after the first space being treated as the - including characters such as spaces and quotes. Reference - Best Practices

ADD Usage: ADD [ ...] ADD ["", ... ""] (this form is required for paths containing whitespace) Information: Copies new files, directories, or remote file URLs from and adds them to the filesystem of the image at the path . may contain wildcards and matching will be done using Go’s filepath.Match rules. If is a file or directory, then they must be relative to the source directory that is being built (the context of the build). is an absolute path, or a path relative to WORKDIR. If doesn’t exist, it is created along with all missing directories in its path. Reference - Best Practices

COPY Usage: COPY [ ...] COPY ["", ... ""] (this form is required for paths containing whitespace) Information: Copies new files or directories from and adds them to the filesystem of the image at the path . may contain wildcards and matching will be done using Go’s filepath.Match rules. must be relative to the source directory that is being built (the context of the build). is an absolute path, or a path relative to WORKDIR. If doesn’t exist, it is created along with all missing directories in its path. Reference - Best Practices

ENTRYPOINT Usage: ENTRYPOINT ["", "", ""] (exec form, preferred) ENTRYPOINT (shell form) Information: Allows you to configure a container that will run as an executable. Command line arguments to docker run will be appended after all elements in an exec form ENTRYPOINT and will override all elements specified using CMD. The shell form prevents any CMD or run command line arguments from being used, but the ENTRYPOINT will start via the shell. This means the executable will not be PID 1 nor will it receive UNIX signals. Prepend exec to get around this drawback. Only the last ENTRYPOINT instruction in the Dockerfile will have an effect. Reference - Best Practices

VOLUME Usage: VOLUME ["", ...] VOLUME [ ...] Creates a mount point with the specified name and marks it as holding externally mounted volumes from native host or other containers. Reference - Best Practices

USER Usage: USER The USER instruction sets the user name or UID to use when running the image and for any RUN, CMD and ENTRYPOINT instructions that follow it in the Dockerfile. Reference - Best Practices

WORKDIR Usage: WORKDIR

Information:

• Sets the working directory for any RUN, CMD, ENTRYPOINT, COPY, and ADD instructions that follow it.
• It can be used multiple times in the one Dockerfile. If a relative path is provided, it will be relative to the path of the previous WORKDIR instruction.

Reference - Best Practices

ARG

Usage:

• ARG [=]

Information:

• Defines a variable that users can pass at build-time to the builder with the docker build command using the --build-arg = flag.
• Multiple variables may be defined by specifying ARG multiple times.
• It is not recommended to use build-time variables for passing secrets like github keys, user credentials, etc. Build-time variable values are visible to any user of the image with the docker history command.
• Environment variables defined using the ENV instruction always override an ARG instruction of the same name.
• Docker has a set of predefined ARG variables that you can use without a corresponding ARG instruction in the Dockerfile.
  • HTTP_PROXY and http_proxy
  • HTTPS_PROXY and https_proxy
  • FTP_PROXY and ftp_proxy
  • NO_PROXY and no_proxy

Reference

ONBUILD

Usage:

• ONBUILD

Information:

• Adds to the image a trigger instruction to be executed at a later time, when the image is used as the base for another build. The trigger will be executed in the context of the downstream build, as if it had been inserted immediately after the FROM instruction in the downstream Dockerfile.
• Any build instruction can be registered as a trigger.
• Triggers are inherited by the "child" build only. In other words, they are not inherited by "grand-children" builds.
• The ONBUILD instruction may not trigger FROM, MAINTAINER, or ONBUILD instructions.

Reference - Best Practices

STOPSIGNAL

Usage:

• STOPSIGNAL

The STOPSIGNAL instruction sets the system call signal that will be sent to the container to exit. This signal can be a valid unsigned number that matches a position in the kernel’s syscall table, for instance 9, or a signal name in the format SIGNAME, for instance SIGKILL.
Reference

HEALTHCHECK

Usage:

• HEALTHCHECK [] CMD (check container health by running a command inside the container)
• HEALTHCHECK NONE (disable any healthcheck inherited from the base image)

Information:

• Tells Docker how to test a container to check that it is still working
• Whenever a health check passes, it becomes healthy. After a certain number of consecutive failures, it becomes unhealthy.
• The that can appear are...
  • --interval= (default: 30s)
  • --timeout= (default: 30s)
  • --retries= (default: 3)
• The health check will first run interval seconds after the container is started, and then again interval seconds after each previous check completes. If a single run of the check takes longer than timeout seconds then the check is considered to have failed. It takes retries consecutive failures of the health check for the container to be considered unhealthy.
• There can only be one HEALTHCHECK instruction in a Dockerfile. If you list more than one then only the last HEALTHCHECK will take effect.
• can be either a shell command or an exec JSON array.
• The command's exit status indicates the health status of the container.
  • 0: success - the container is healthy and ready for use
  • 1: unhealthy - the container is not working correctly
  • 2: reserved - do not use this exit code
• The first 4096 bytes of stdout and stderr from the are stored and can be queried with docker inspect.
• When the health status of a container changes, a health_status event is generated with the new status.

Reference

SHELL

Usage:

• SHELL ["", "", ""]

Information:

• Allows the default shell used for the shell form of commands to be overridden.
• Each SHELL instruction overrides all previous SHELL instructions, and affects all subsequent instructions.
• Allows an alternate shell be used such as zsh, csh, tcsh, powershell, and others.

Reference

K8S CHEATSHEET

HELM CHEAT SHEET

Choco install -y kubernetes-helm :

•     helm version --short
•     helm search: search for charts
•     helm fetch: download a chart to our local directory to view
•     helm install: upload the chart to Kubernetes
•     helm list: list releases of charts

Helm Add Repositories :
helm repo add stable https://kubernetes-charts.storage.googleapis.com
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update

Helm Search Repositories :
helm search repo bitnami/nginx
helm list
helm ls -all

Helm Install and Uninstall Package :
helm install bitnami/nginx mywebserver
helm install dashboard-demo stable/kubernetes-dashboard --set rbac.clusterAdminRole=true
helm uninstall mywebserver
helm delete mywebserver

Helm Rollback :
helm status mywebserver
helm history mywebserver
helm rollback mywebserver -1

Kubectl Help :
kubectl get svc,po,deploy
kubectl describe deployment mywebserver
kubectl get pods -l app.kubernetes.io/name=nginx
kubectl get service mywebserver-nginx -o wide
kubectl get pods -n kube-system


CLUSTERS FOR PRACTICE :

• Play with Kubernetes: A simple, interactive and fun playground to learn Kubernetes
• Katacoda’s Kubernetes Playground: no installs or setup, just tutorials on a cluster
• Minikube: local testing and getting comfortable with kubectl
• Google Kubernetes Enginer (GKE): by far the fastest way to get a multi node cluster running.
• Kelsey Hightower’s Kubernetes The Hard Way: the definitive way to learn how to set up a cluster. 
• Kubernetes Examples: how to run real applications with Kubernetes