Merge pull request #177 from Lemoncode/eks-review

Eks review

Author: JaimeSalas

04-cloud/01-eks/01-create-aws-user/readme.md

@@ -17,15 +17,15 @@ Para poder crear un usuario con permisos de administrador previamente debemos cr
 ## Creando un grupo
 
 ```bash
-$ aws iam create-group --group-name <group-name>
+aws iam create-group --group-name <group-name>
 ```
 
 > Contsraits: The name can consist of letters, digits, and the following characters: plus (+), equal (=), comma (,), period (.), at (@), underscore (_), and hyphen (-). The name is not case sensitive and can be a maximum of 128 characters in length.
 
 Para verificar que hemos tenido exito en nuestra operación
 
 ```bash
-$ aws iam list-groups
+aws iam list-groups
 ```
 
 La respuesta incluye el `Amazon Resource Name` (ARN) para el nuevo grupo. El `ARN` es un standard  que Amazon utiliza para identificar recursos.
@@ -35,13 +35,13 @@ La respuesta incluye el `Amazon Resource Name` (ARN) para el nuevo grupo. El `AR
 Utilizando el siguiente comando enlazamos la política de administardor con el grupo recientemenet creado 
 
 ```bash
-$ aws iam attach-group-policy --group-name <group-name> --policy-arn arn:aws:iam::aws:policy/AdministratorAccess
+aws iam attach-group-policy --group-name <group-name> --policy-arn arn:aws:iam::aws:policy/AdministratorAccess
 ``` 
 
 Para verificar que la política se ha atado correctamente al grupo 
 
 ```bash
-$ aws iam list-attached-group-policies --group-name <group-name>
+aws iam list-attached-group-policies --group-name <group-name>
 ``` 
 
 La respuesta nos da la lista de políticas atadas al grupo. Si queremos comprobar los contenidos de una política en particular podemos usar `aws iam get-policy`
@@ -51,13 +51,13 @@ La respuesta nos da la lista de políticas atadas al grupo. Si queremos comproba
 ### 1. Creamos un usuario
 
 ```bash
-$ aws iam create-user --user-name eksAdmin
+aws iam create-user --user-name eksAdmin
 ```
 
 ### 2. Añadiendo el Usuaro a un grupo
 
 ```bash
-$ aws iam add-user-to-group --group-name <group-name>  --user-name <user-name>
+aws iam add-user-to-group --group-name <group-name>  --user-name <user-name>
 ``` 
 
 
@@ -70,13 +70,13 @@ https://My_AWS_Account_ID.signin.aws.amazon.com/console/
 ```
 
 ```bash
-$ aws iam create-login-profile --generate-cli-skeleton > create-login-profile.json
+aws iam create-login-profile --generate-cli-skeleton > create-login-profile.json
 ```
 
 Genera un `template`, que ahora podemos utilizar para inicializar el usuario
 
 ```bash
-$ aws iam create-login-profile --cli-input-json file://create-login-profile.json
+aws iam create-login-profile --cli-input-json file://create-login-profile.json
 ``` 
 
 Esto nos da como salida
@@ -102,7 +102,7 @@ google https://xxxxxxxxxxxx.signin.aws.amazon.com/console/
 Con esta `key` nuestro nuevo usuario tendrá acceso programático desde `AWS CLI`
 
 ```bash
-$ aws iam create-access-key --user-name <user-name>
+aws iam create-access-key --user-name <user-name>
 ``` 
 
 Con la salida anterior podemos configurar nuestro usurio por defecto usando `aws configute`

04-cloud/01-eks/02-launching-cluster-eks/readme.md

@@ -27,7 +27,7 @@ chmod 400 EksKeyPair.pem
 With this new private key we can go ahead and generate a public one, that's the key that will be upload into the node (EC2 instance). If we provide this key, and we have the private one, we can connect to the remote instance.
 
 ```bash
-$ ssh-keygen -y -f EksKeyPair.pem > eks_key.pub
+ssh-keygen -y -f EksKeyPair.pem > eks_key.pub
 ```
 
 ## Create definition YAML
@@ -132,7 +132,7 @@ eksctl create cluster -f demos.yml
 Now we can test that our cluster is up and running.
 
 ```bash
-$ kubectl get nodes
+kubectl get nodes
 ```
 
 > `eksctl` has edit `./kube/config` to make `kubectl` point to the new created cluster.

04-cloud/01-eks/03-deploy-k8s-dashboard/readme.md

@@ -8,9 +8,15 @@ We can deploy the dashboard with the following command:
 
 ```bash
 export DASHBOARD_VERSION="v2.0.0"
+```
+
+```bash
+kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/${DASHBOARD_VERSION}/aio/deploy/recommended.yaml
+```
 
-$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/${DASHBOARD_VERSION}/aio/deploy/recommended.yaml
+We get the following output:
 
+```
 namespace/kubernetes-dashboard created
 serviceaccount/kubernetes-dashboard created
 service/kubernetes-dashboard created
@@ -30,7 +36,10 @@ deployment.apps/dashboard-metrics-scraper created
 If we have a look into our services we can find
 
 ```bash
- kubectl get services --all-namespaces
+kubectl get services --all-namespaces
+```
+
+```
 NAMESPACE              NAME                        TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)         AGE
 default                kubernetes                  ClusterIP   10.100.0.1     <none>        443/TCP         3h15m
 kube-system            kube-dns                    ClusterIP   10.100.0.10    <none>        53/UDP,53/TCP   3h15m
@@ -43,7 +52,7 @@ kubernetes-dashboard   kubernetes-dashboard        ClusterIP   10.100.9.10    <n
 Since this is deployed to our private cluster, we need to access it via a proxy. `kube-proxy` is available to proxy our requests to the dashboard service. In your workspace, run the following command:
 
 ```bash
-$ kubectl proxy --port=8080 --address=0.0.0.0 --disable-filter=true &
+kubectl proxy --port=8080 --address=0.0.0.0 --disable-filter=true &
 ```
 
 > Running from a local environment is enough to do `kubectl proxy --port=8080` (or any other port that we want to use)
@@ -61,7 +70,7 @@ google localhost:8080/api/v1/namespaces/kubernetes-dashboard/services/https:kube
 To access the dashboard we have to provide a `token`, we can achive this by running the following:
 
 ```bash
-$ aws eks get-token --cluster-name lc-cluster | jq -r '.status.token'
+aws eks get-token --cluster-name lc-cluster | jq -r '.status.token'
 ```
 
 Copy the output of this command and then click the radio button next to Token then in the text field below paste the output from the last command

04-cloud/01-eks/04-deploy-solution/readme.md

@@ -245,9 +245,9 @@ aws iam get-role --role-name "AWSServiceRoleForElasticLoadBalancing" || aws iam
 Let's bring up the Frontend
 
 ```bash
-$ cd lc-front
-$ kubectl apply -f kubernetes/deployment.yaml
-$ kubectl apply -f kubernetes/service.yaml
+cd lc-front
+kubectl apply -f kubernetes/deployment.yaml
+kubectl apply -f kubernetes/service.yaml
 ``` 
 
 We can check the progress by looking at the deployment status:
@@ -267,21 +267,21 @@ Be aware AL is L7 on OSI model, and only spports http and https, some kind of co
 Now that we have a running service that is `type: LoadBalancer` we need to find the ELB's address.
 
 ```bash
-$ kubectl get service lc-front
+kubectl get service lc-front
 ```
 
 or
 
 ```bash
-$ kubectl get service lc-front -o wide
+kubectl get service lc-front -o wide
 ```
 
 If we want to use the data programmatically, we can also output via json
 
 ```bash
-$ ELB=$(kubectl get service lc-front -o json | jq -r '.status.loadBalancer.ingress[].hostname')
+ELB=$(kubectl get service lc-front -o json | jq -r '.status.loadBalancer.ingress[].hostname')
 
-$ curl -m3 -v $ELB
+curl -m3 -v $ELB
 ```
 
 > NOTE: It will take several minutes for ELB to become healthy and start passing traffic to the frontend pods.
@@ -291,14 +291,14 @@ $ curl -m3 -v $ELB
 When we launched our services, we only launched one container of each. We can confirm this by viewing the running pods:
 
 ```bash
-$ kubectl get deployments
+kubectl get deployments
 ```
 
 Now let's scale up the backend services:
 
 ```bash
-$ kubectl scale deployment lc-age-service --replicas=3
-$ kubectl scale deployment lc-name-service --replicas=3
+kubectl scale deployment lc-age-service --replicas=3
+kubectl scale deployment lc-name-service --replicas=3
 ```
 
 Confirm by looking at deployments again

04-cloud/01-eks/05-helm/01-install-helm.md

@@ -17,13 +17,13 @@
 Before we can get started configuring Helm, we'll need to first install the command line tools.
 
 ```bash
-$ curl -sSL https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash
+curl -sSL https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash
 ```
 
 We can verify the installation by
 
 ```bash
-$ helm version --short
+helm version --short
 ```
 
 Let’s configure our first Chart repository. Chart repositories are similar to APT or yum repositories that you might be familiar with on Linux, or Taps for Homebrew on macOS.
@@ -37,5 +37,5 @@ helm repo add stable https://charts.helm.sh/stable
 Once this is installed, we will be able to list the charts you can install:
 
 ```bash
-$ helm search repo stable
+helm search repo stable
 ```

04-cloud/01-eks/05-helm/02-deploy-nginx-with-helm.md

@@ -26,13 +26,13 @@ Now that our repository Chart list has been updated, we can [search for Charts](
 To list all Charts:
 
 ```bash
-$ helm search repo
+helm search repo
 ```
 
 You can see from the output that it dumped the list of all Charts we have added. In some cases that may be useful, but an even more useful search would involve a keyword argument. So next, we’ll search just for nginx:
 
 ```bash
-$ helm search repo nginx
+helm search repo nginx
 ```
 
 The results in:
@@ -57,7 +57,7 @@ After a quick web search, we discover that there is a Chart for the nginx standa
 
 
 ```bash
-$ helm repo add bitnami https://charts.bitnami.com/bitnami
+helm repo add bitnami https://charts.bitnami.com/bitnami
 ```
 
 Once that completes, we can search all Bitnami Charts:
@@ -70,7 +70,7 @@ helm search repo bitnami
 Search once again for nginx
 
 ```bash
-$ helm search repo nginx
+helm search repo nginx
 ```
 
 Now we are seeing more nginx options, across both repositories:
@@ -84,7 +84,7 @@ stable/nginx-ingress                    1.41.3          v0.34.1         DEPRECAT
 Or even search the Bitnami repo, just for nginx:
 
 ```bash
-$ helm search repo bitnami/nginx
+helm search repo bitnami/nginx
 
 ```
 
@@ -97,13 +97,13 @@ A Helm Chart can be installed multiple times inside a Kubernetes cluster. This i
 For this reason, you must supply a unique name for the installation, or ask Helm to generate a name for you.
 
 ```bash
-$ helm install mywebserver bitnami/nginx --dry-run
+helm install mywebserver bitnami/nginx --dry-run
 ```
 
 Now to really install nginx on our cluster, we can run:
 
 ```bash
-$ helm install mywebserver bitnami/nginx
+helm install mywebserver bitnami/nginx
 ```
 
 The output is simillar to this
@@ -137,8 +137,12 @@ To access NGINX from outside the cluster, follow the steps below:
 In order to review the underlying Kubernetes services, pods and deployments, run:
 
 ```bash
-$ kubectl get svc,po,deploy
+kubectl get svc,po,deploy
+```
+
+We get something similar to this:
 
+```
 NAME                        TYPE           CLUSTER-IP     EXTERNAL-IP                                                              PORT(S)        AGE
 service/kubernetes          ClusterIP      10.100.0.1     <none>                                                                   443/TCP        136m
 service/mywebserver-nginx   LoadBalancer   10.100.9.232   a7130a0207757453594c4cb5bdf072e5-381544302.eu-west-3.elb.amazonaws.com   80:31519/TCP   2m38s
@@ -155,28 +159,33 @@ The first object shown in this output is a Deployment. A Deployment object manag
 You can inspect this Deployment object in more detail by running the following command:
 
 ```bash
-$ kubectl describe deployment mywebserver
-
+kubectl describe deployment mywebserver
 ```
 
 The next object shown created by the Chart is a Pod. A Pod is a group of one or more containers.
 
 To verify the Pod object was successfully deployed, we can run the following command:
 
 ```bash
-$ kubectl get pods -l app.kubernetes.io/name=nginx
+kubectl get pods -l app.kubernetes.io/name=nginx
+```
 
+We can check that the container inside the pod is running:
+
+```
 NAME                                 READY   STATUS    RESTARTS   AGE
 mywebserver-nginx-857766d4fd-9tdwf   1/1     Running   0          4m48s
-
 ```
+
 The third object that this Chart creates for us is a Service. A Service enables us to contact this nginx web server from the Internet, via an Elastic Load Balancer (ELB).
 
 To get the complete URL of this Service, run:
 
 ```bash
-$ kubectl get service mywebserver-nginx -o wide
+kubectl get service mywebserver-nginx -o wide
+```
 
+```
 NAME                TYPE           CLUSTER-IP     EXTERNAL-IP                                                              PORT(S)        AGE     SELECTOR
 mywebserver-nginx   LoadBalancer   10.100.9.232   a7130a0207757453594c4cb5bdf072e5-381544302.eu-west-3.elb.amazonaws.com   80:31519/TCP   6m22s   app.kubernetes.io/instance=mywebserver,app.kubernetes.io/name=nginx
 ```
@@ -190,7 +199,10 @@ To remove all the objects that the Helm Chart create we can use [helm uninstall]
 Before we uninstall our application, we can verify what we have running via the [helm list](https://helm.sh/docs/helm/helm_list/) command:
 
 ```bash
-$ helm list
+helm list
+```
+
+```
 WARNING: Kubernetes configuration file is group-readable. This is insecure. Location: /home/lemoncode/.kube/config
 WARNING: Kubernetes configuration file is world-readable. This is insecure. Location: /home/lemoncode/.kube/config
 NAME            NAMESPACE       REVISION        UPDATED                                 STATUS          CHART           APP VERSION
@@ -200,7 +212,7 @@ mywebserver     default         1               2020-12-21 15:45:05.835403883 +0
 To uninstall:
 
 ```bash
-$ helm uninstall mywebserver
+helm uninstall mywebserver
 
 ```
 

04-cloud/01-eks/06-autoscalling-our-applications/00-install-kube-ops-view.md

@@ -13,7 +13,6 @@ helm install kube-ops-view \
 stable/kube-ops-view \
 --set service.type=LoadBalancer \
 --set rbac.create=True
-
 ```
 
 The execution above installs kube-ops-view exposing it through a Service using the LoadBalancer type. A successful execution of the command will display the set of resources created and will prompt some advice asking you to use `kubectl proxy` and a local URL for the service. Given we are using the type LoadBalancer for our service, we can disregard this; Instead we will point our browser to the external load balancer.
@@ -24,6 +23,9 @@ To check the chart was installed successfully:
 
 ```bash
 helm list
+``` 
+
+```
 WARNING: Kubernetes configuration file is group-readable. This is insecure. Location: /home/lemoncode/.kube/config
 WARNING: Kubernetes configuration file is world-readable. This is insecure. Location: /home/lemoncode/.kube/config
 NAME            NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
@@ -34,9 +36,22 @@ With this we can explore kube-ops-view output by checking the details about the
 
 ```bash
 kubectl get svc kube-ops-view | tail -n 1 | awk '{ print "Kube-ops-view URL = http://"$4 }'
-
 ```
 
 This will display a line similar to Kube-ops-view URL = http://<URL_PREFIX_ELB>.amazonaws.com Opening the URL in your browser will provide the current state of our cluster.
 
-> Reference: https://kubernetes-operational-view.readthedocs.io/en/latest/
+> Reference: https://kubernetes-operational-view.readthedocs.io/en/latest/
+
+## Alternative installation
+
+```bash
+helm repo add christianknell https://christianknell.github.io/helm-charts
+helm repo update
+```
+
+```bash
+helm install kube-ops-view \
+ christianknell/kube-ops-view \
+ --set service.type=LoadBalancer
+```
+