
### EKS prerequisite

- create cluster

```bash
eksctl create cluster --name=petlover-back \
                      --region=ap-southeast-2 \
                      --zones=ap-southeast-2a,ap-southeast-2b \
                      --without-nodegroup
```

- create OIDC and node group (With '--approve'
   it will replace the service account with a new one)

```bash

eksctl utils associate-iam-oidc-provider \
    --region ap-southeast-2 \
    --cluster petlover-back \
    --approve
```

- create node group
  1. These add-ons will create the respective IAM policies for us automatically within our Node Group role.

```bash
# Create Public Node Group
eksctl create nodegroup --cluster=petlover-back \
                       --region=ap-southeast-2 \
                       --name=petlover-back-ng-public1 \
                       --node-type=t3.medium \
                       --nodes=2 \
                       --nodes-min=2 \
                       --nodes-max=4 \
                       --node-volume-size=20 \
                       --ssh-access \
                       --ssh-public-key=my_key \
                       --managed \
                       --asg-access \
                       --external-dns-access \
                       --full-ecr-access \
                       --appmesh-access \
                       --alb-ingress-access \
											 --node-private-networking # for private VPC
```

- delete group nodes

```bash
eksctl delete nodegroup --cluster=petlover --name=petlover-back-ng-public1

eksctl delete cluster petlover-back
```

- 如果不能访问到 aws eks？使用
- fix: aws eks update-kubeconfig --region region-code --name my-cluster

```bash
aws eks --region ap-southeast-2 update-kubeconfig --name petlover-uat
```

### 本地 call remote private ECR (Secret)

1. [https://skryvets.com/blog/2021/03/15/kubernetes-pull-image-from-private-ecr-registry/](https://skryvets.com/blog/2021/03/15/kubernetes-pull-image-from-private-ecr-registry/)
2. [https://medium.com/@danieltse/pull-the-docker-image-from-aws-ecr-in-kubernetes-dc7280d74904](https://medium.com/@danieltse/pull-the-docker-image-from-aws-ecr-in-kubernetes-dc7280d74904)

   1. 注意，这里的 namespace 可以用 default
   2. 注意本地环境变量

   ```bash
   kubectl create secret docker-registry regcred \
   --docker-server=[046381260578.dkr.ecr.ap-southeast-2.amazonaws.com](http://046381260578.dkr.ecr.ap-southeast-2.amazonaws.com/) \
   --docker-username=AWS \
   --docker-password=$(aws ecr get-login-password --region ap-southeast-2) \
   --namespace=default
   ```

   常见 key，regcred，用来储存 key （key 被放在 .dockerconfigjson 中）

3. 获得当前 context：kubectl config current-context
   1. arn:aws:eks:ap-southeast-2:0463812XXXX:cluster/petlover-uat ← AWS cluster name
   2. Petlover-Prod ← Azure Aks cluster Name
4. minikube service <service-name> —url 启动本地 service 服务器
5. kubectl get secret regcred --output=yaml 输出新建的秘钥，以 yaml 格式
6. kubectl delete secret regcred 删除秘钥
7. sudo service docker start 启动 docker 服务器
8. echo -n ‘<加密内容>’ | base64 然后返贴回到 secret file 中

### EKS EBS

- CSI: container storage interface
- EBS: elastic block storage (for persistent volumes); provides block level storage for use with EC2 & container instance
- EBS volumes exposed as storage volumes that persist independently from the life of the EC2 or container instance
- SC(storage class) 和 PV（persistence volume） is not namespace based
- PVC(persistence volume claim) 配合 SC，可以 dynamic assign storage。不需要提前购买 storage，然后开发（PVC）再去 claim 可获得的 storage
- 老版本的是，先购买 PV，再提出 PVC，再分配 storage

Demo

1. add IAM policy(EC2 to access EBS) to node group and apply CSI driver: [https://github.com/stacksimplify/aws-eks-kubernetes-masterclass/tree/master/04-EKS-Storage-with-EBS-ElasticBlockStore/04-01-Install-EBS-CSI-Driver](https://github.com/stacksimplify/aws-eks-kubernetes-masterclass/tree/master/04-EKS-Storage-with-EBS-ElasticBlockStore/04-01-Install-EBS-CSI-Driver)

### EKS Cluster

- EKS control plane (master node)
  1. is not shared across clusters or AWS account
  2. consists of at least two API server nodes and three ETCD nodes that run across three AZs within a region
  3. EKS handle unhealthy control plane instances, restarting them across the AZ within the region
- worker nodes & node groups
  1. run to connect to our cluster’s control plane via the cluster API server endpoint
  2. more instances in the node group are deployed in an EC2 autoscaling group
  3. all instances in a group must be: the same instance type, running the same AMI and use the same worker node IAM role
- fargate profiles
  1. AWS specially built Fargate Controllers that recognize the pods belonging to fargate and schedule them on fargate profiles
- RBAC policies
  1. RBAC policies as authorized, 允许跨 cluster，aws accounts 访问
- OIDC: Open ID Connect provider

### EKS eksctl

![55767f52e49cd59144143a2ca098761.png](55767f52e49cd59144143a2ca098761.png)

![Untitled](<k8s_eks%20(26).png>)

![Untitled](<k8s_eks%20(27).png>)

![Untitled](<k8s_eks%20(28).png>)

- AMI update: master node 更新，没事，反正一直是 aws 自己管理的，我们看不出啥。。。
  然后 slavor node 更新，我更新 ami，desired 原来是 4，然后直接给我拓展到了 10 个 实际运行的 node 还是 11 个。。。 可能 micro 不太行吧，顶不住。。。
  不过 pod 一直是我稳定定义的 3 个，内部在 rolling update
- The Kubernetes Metrics Server: is an aggregator of resource usage data in your cluster. Server is commonly used by other Kubernetes add ons, such as the [Horizontal Pod Autoscaler](https://docs.aws.amazon.com/eks/latest/userguide/horizontal-pod-autoscaler.html) or the [Kubernetes Dashboard](https://docs.aws.amazon.com/eks/latest/userguide/dashboard-tutorial.html)

### Security: RBAC, IRSA, ClusterRole, ClusterRoleBinding

RBAC: Role based access control

IRSA: IAM role service account

- Pod needs IAM role to implement AWS resource → pod lifecycle is short → k8s deployment can handle this but deployment is construct → IAM cannot in k8s construct → need cloud-specific construct → service account SA
- SA is in AWS EKS inside, it needs to verify with IAM by IAM OIDC Provider (Cluster Level)

![Untitled](<k8s_eks%20(29).png>)

![Untitled](<k8s_eks%20(30).png>)

- cluster role: grant cluster to access resources: eg. nodes, pods communicate; cluster roles is not namespace limited。 （相当于 aws 的 policy）
- SA 也是某种形式的 cluster role 因为其有权限操作 cluster 内部的资源，但是不能 create new pod eg. alb-ingress-controller

![Untitled](<k8s_eks%20(31).png>)

![Untitled](<k8s_eks%20(32).png>)

![Untitled](<k8s_eks%20(33).png>)

- how to create cluster role and SA? 分别创建，然后 combined 在一起
- role vs cluster role？
  1. Role sets permission within a particular namespace (have to specify namespace) (what we say 当你定义 ns 的时候定义的 role，就是 role；所以是 namespace role)
  2. clusterRole is non-namespaced
- 给用户权限

![Untitled](<k8s_eks%20(34).png>)

![Untitled](<k8s_eks%20(35).png>)

### Ingress Load balancer controller 1

ALB?

![Untitled](<k8s_eks%20(36).png>)

![Untitled](<k8s_eks%20(37).png>)

![Untitled](<k8s_eks%20(38).png>)

![Untitled](<k8s_eks%20(39).png>)

![Untitled](<k8s_eks%20(40).png>)

- 在 k8s 内部，我们叫他 ingress service，在 aws 中，我们叫他 aws alb 但其实他们是等价的（equivalent），我们把他们称为一个 aws application load balancer object (single object)

![Untitled](<k8s_eks%20(41).png>)

### Ingress Load Balancer Controller 2

- prerequisite: 安装 cluster + nodes group + OIDC provider
- 下载 iam policy JSON file

  1.

  ```bash
  curl -o iam_policy_latest.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/main/docs/install/iam_policy.json
  ```

  2. 并创建 policy

  ```bash
  aws iam create-policy \
      --policy-name AWSLoadBalancerControllerIAMPolicy \
      --policy-document file://iam_policy_latest.json
  ```

  3. 记录 arn
  4. 创建 iam service account，绑定 policy 到 role 上

  ```bash
  eksctl create iamserviceaccount \
    --cluster=petlover-back \
    --namespace=kube-system \
    --name=aws-load-balancer-controller \
    --attach-policy-arn=arn:aws:iam::046381260578:policy/AWSLoadBalancerControllerIAMPolicy \
    --override-existing-serviceaccounts \
    --approve
  ```

  5. install aws LBC by Helm

  ```bash
  helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
    -n kube-system \
    --set clusterName=petlover-back \
    --set serviceAccount.create=false \
    --set serviceAccount.name=aws-load-balancer-controller

  // omit it now
    --set region=us-east-1 \
    --set vpcId=vpc-0165a396e41e292a3 \
    --set image.repository=602401143452.dkr.ecr.us-east-1.amazonaws.com/amazon/aws-load-balancer-controller
  ```

  6. Optional useful command:

  ```bash
  helm uninstall aws-load-balancer-controller -n kube-system
  ```

- Ingress class? 如果多个 ingress controller running in k8s cluster, how to identify to which ingress controller our Ingress resource? should be associated with? → K8s object type object —— need to associate with ALB ingress controller (定义在 k8s cluster 中，设置默认 controller)
- controller deployment 里只有两个东西，一个是 metric server，一个是 webhook-server（由 controller service 暴露服务，进行触发）

### External DNS

![Untitled](<k8s_eks%20(42).png>)



**Attention:** all the command is based on Win PowerShell

### Prerequisite

1. install az 'azure-cli'
2. az login ->
   copy code 到本地 brower 去打开，并粘贴进 codes
3. install azure aks cli

```bash
# Install Azure AKS CLI
az aks install-cli
```

4. 创建 aks cluster， node pool, VNet….. (手动)
5. configure cluster creds, kube config

```bash
# Configure Cluster Creds (kube config)
az aks get-credentials --resource-group petlover-AKS --name Petlover-Prod
```

6. set up powershell cmd faster way: set kubectl to k……

[Set Alias for Kubectl](https://www.techtarget.com/searchitoperations/tutorial/Manage-Kubernetes-clusters-with-PowerShell-and-kubectl#:~:text=Kubectl aliasing in PowerShell&text=Aliasing in PowerShell is the,name to reference a command.&text=After setting up this alias,make a call to Kubernetes).

### Ingress Nginx Load Balancer Controller

![Untitled](<aks%20(46).png>)

![Untitled](<aks%20(47).png>)

1. create a static IP address

```bash
# Get the resource group name of the AKS cluster (resource name -> aks name)
az aks show --resource-group petlover-AKS --name Petlover-Prod --query nodeResourceGroup -o tsv

# record resource group name: MC_petlover-AKS_Petlover-Prod_eastus

# TEMPLATE - Create a public IP address with the static allocation
az network public-ip create --resource-group MC_petlover-AKS_Petlover-Prod_eastus \
                            --name myAKSPublicIPForIngress \
                            --sku Standard \
                            --allocation-method static \
                            --query publicIp.ipAddress \
                            -o tsv

# record public IP address
```

2. install helm (in powershell) ⇒ Jenkins server 中也需要安装

run PowerShell as admin → choco install kubernetes-helm

3. add official stable repo

```bash
# Create a namespace for your ingress resources
kubectl create namespace ingress-basic

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

#  Customizing the Chart Before Installing.
helm show values ingress-nginx/ingress-nginx

# Use Helm to deploy an NGINX ingress controller
helm install ingress-nginx ingress-nginx/ingress-nginx \
    --namespace ingress-basic \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set defaultBackend.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.service.externalTrafficPolicy=Local \
    --set controller.service.loadBalancerIP="20.124.104.64"
```

### External DNS - By Managed Service Identity (MSI)

![Untitled](<aks%20(48).png>)

1. get tenantId and subscription ID

```bash
# To get Azure Tenant ID
az account show --query "tenantId"# To get Azure Subscription ID
az account show --query "id"
```

2. **Create MSI - Managed Service Identity for External DNS to access Azure DNS Zones**

![Untitled](<aks%20(49).png>)

record user assigned identity ID:

3. create Json file

   ```json
   {
     "tenantId": "b985d900-a4c4-4ea6-9e09-8d1167bac273",
     "subscriptionId": "c4c2e681-0156-457e-b1f2-88020d2efe5c",
     "resourceGroup": "petlover-AKS",
     "useManagedIdentityExtension": true,
     "userAssignedIdentityID": "cc69d3df-0680-4e72-9a58-33bc57b09587"
   }
   ```

4. associate MSI in AKS Cluster VMSS

![Untitled](<aks%20(50).png>)

5. create kub secret and deploy ExternalDNS

'kubectl create secret generic azure-config-file --from-file=azure.json'

apply external-dns.yaml

### Ingress - SSL

![Untitled](<aks%20(51).png>)

- Label the ingress-basic namespace to disable resource validation

  ```bash
  kubectl label namespace ingress-basic [cert-manager.io/disable-validation=true](http://cert-manager.io/disable-validation=true)
  ```

- Add the Jetstack Helm repository

  ```bash
  helm repo add jetstack [https://charts.jetstack.io](https://charts.jetstack.io/)
  ```

- Update your local Helm chart repository cache

  helm repo update

- Install the cert-manager Helm chart
  ```bash
  helm install \
  cert-manager jetstack/cert-manager \
  --namespace ingress-basic \
  --version v1.8.2 \
  --set installCRDs=true
  ```
  ```powershell
  helm install cert-manager jetstack/cert-manager --namespace ingress-basic --version v1.8.2 --set installCRDs=true
  ```

### ACR Connection - By Service Principle

![Untitled](<aks%20(52).png>)

1. create ACR
2. access keys → enable admin user
3. 用这个 username 和 password 去登录 acr，并上传 images

```bash
# Export Command
export ACR_REGISTRY=acrdemo2ss.azurecr.io
export ACR_NAMESPACE=app2
export ACR_IMAGE_NAME=acr-app2
export ACR_IMAGE_TAG=v1
echo $ACR_REGISTRY, $ACR_NAMESPACE, $ACR_IMAGE_NAME, $ACR_IMAGE_TAG

# Login to ACR
docker login $ACR_REGISTRY

# Tag
docker tag acr-app2:v1  $ACR_REGISTRY/$ACR_NAMESPACE/$ACR_IMAGE_NAME:$ACR_IMAGE_TAG
It replaces as below
docker tag acr-app2:v1 acrdemo2ss.azurecr.io/app2/acr-app2:v1

# List Docker Images to verify
docker images acr-app2:v1
docker images $ACR_REGISTRY/$ACR_NAMESPACE/$ACR_IMAGE_NAME:$ACR_IMAGE_TAG

# Push Docker Images
docker push $ACR_REGISTRY/$ACR_NAMESPACE/$ACR_IMAGE_NAME:$ACR_IMAGE_TAG
```

```powershell
docker tag petlover-back:latest petloverprod[.azurecr.io/back/petlover-back:](http://demopublicpetlover.azurecr.io/app1/demo:v1)latest
docker push petloverprod.azurecr.io/back/petlover-back:latest
```

4. create service principle

```bash
#!/bin/bash
# This script requires Azure CLI version 2.25.0 or later. Check version with `az --version`.

# Modify for your environment.
# ACR_NAME: The name of your Azure Container Registry
# SERVICE_PRINCIPAL_NAME: Must be unique within your AD tenant
ACR_NAME=acrdemo2ss
SERVICE_PRINCIPAL_NAME=acr-sp-demo

# Obtain the full registry ID for subsequent command args
ACR_REGISTRY_ID=$(az acr show --name $ACR_NAME --query id --output tsv)# Create the service principal with rights scoped to the registry.
# Default permissions are for docker pull access. Modify the '--role'
# argument value as desired:
# acrpull:     pull only
# acrpush:     push and pull
# owner:       push, pull, and assign roles
SP_PASSWD=$(az ad sp create-for-rbac --name $SERVICE_PRINCIPAL_NAME --scopes $ACR_REGISTRY_ID --role acrpull --query password --output tsv)
SP_APP_ID=$(az ad sp list --display-name $SERVICE_PRINCIPAL_NAME --query [].appId --output tsv)# Output the service principal's credentials; use these in your services and
# applications to authenticate to the container registry.
echo "Service principal ID: $SP_APP_ID"echo "Service principal password: $SP_PASSWD"
```

Or

```powershell
$ACR_NAME='petloverprod'
$SERVICE_PRINCIPAL_NAME='acr-petlover-demo'
$ACR_REGISTRY_ID=$(az acr show --name $ACR_NAME --query id --output tsv)

$SP_PASSWD=$(az ad sp create-for-rbac --name http://$SERVICE_PRINCIPAL_NAME --scopes $ACR_REGISTRY_ID --role acrpull --query password --output tsv)

$SP_APP_ID=$(az ad app list --display-name http://$SERVICE_PRINCIPAL_NAME --query [].appId --output tsv)

ps(解读，不必操作):
az ad sp create-for-rbac --name <service_principal_name> --role Contributor --scopes /subscriptions/<subscription_id>
等价于：
az ad sp create-for-rbac --name myAKSClusterServicePrincipal
az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --service-principal <appId> \
    --client-secret <password>
az role assignment create --assignee <appId> --scope <resourceScope> --role Contributor

1. 创建一个principal identity
2. 创建一个resource group并且使用该principal identity （正常可由tf创建完成）
3. role assign 给一个resource group by scope
```

5. create image pull secret

```bash
kubectl create secret docker-registry <named_secret> \
    --namespace default \
    --docker-server=acrdemo.azurecr.io \
    --docker-username=<$SP_APP_ID> \
    --docker-password=<$SP_PASSWD>
```

```powershell
kubectl create secret docker-registry my-secret --namespace default --docker-server=$ACR_NAME[.azurecr.io](http://demopublicpetlover.azurecr.io/) --docker-username=$SP_APP_ID --docker-password=$SP_PASSWD
```

note: kubectl delete secrete my-secret 可以删除 创建的 secret

### 关于 ssh 连接到对方服务器的问题

- 发送建立链接
  1. 将自己的公钥传递给对方节点
  2. 交换公钥，是否相互信任对方
  3. 然后就可以登录



### DevOps K8s Overview 1

- K8s?
  1. managing containerized workloads and services;
  2. when u deploy k8s, u get a cluster.
- service? an abstract way to expose an application, 提供 IP(cluster IP)， single DNS, port for a set of pods
- pods?
  1. the components of the application workload;
  2. the smallest deployable units of computing that you can create and manage in k8s;
  3. a group of containers, share with namespaces, filesystem volumes and network resources.
  4. 在一个 specific LOGICAL HOST 中，没给 container relatively tightly coupled. (in a non-cloud context, the same physical or VM are executed on the same LOGICAL HOST.)
- Node? == VM machine; host the Pods that are the components of the application workload.
- Control panel? in prod, the control panel run across multiple computers.
- namespace? : resource name needs to be same (eg. env, prod…)
- targetport? a service that can map any incoming port to a target port.

## DevOps K8s Overview 2

- Ingress controller: 用户使用 domain name 访问 ingress contoller，然后根据域名分配到不同的 services （音乐，流媒体播放，购物 XXXX）
- dirty job：
  1. Azure K8s service
  2. GCP k8s service
  3. AWS EKS
- control plan: Azure Kubernetes service cluster (auto-scaling)
- Cosmos DB： AZ NoSQL DB
- Grafana： visualize logs（metrics）， grab data from azure data source 估计是从 nosql 中抓 log 信息，之后会详细讲
- relationship
  1. 1 k8s cluster has many Node(VM) (fault tolerance and high availability)
  2. 1 service has many pods.
  3. 1 Node has at least one Pod (The worker nodes host the Pods )
  4. 1 Pod has at least one container

### DevOps K8s Deep 1

![Untitled](Untitled%2054.png)

![IMG_0408.PNG](IMG_0408.png)

![IMG_0409.PNG](IMG_0409.png)

K8s 的设计，更强大，更灵活，更 robust；basic info 参考之前的博文

docker flaws: all docker in one EC2 -> single point failure.

Control panel == orchestrator

K8s provide

1. Service discovery and load balance：k8s can find where the Service based on requirements and k8s can expose a container to be a DNS
2. Storage orchestration: 本地存储和云存储
3. automated rollouts and rollback：多个 contianer 同时回滚代码，配置
4. automatic bin packing：保证 each server runs the max capacity => open new or scale down.(一般控制每个 node cpu<60%)，也可自定义分配
5. Self-healing： 检测 health，自动更换坏的，确保完全 work 后才 release
6. secret and config management: env variable and password centralised be organised.

Control panel:

1. 决定哪些 pod 放到哪些 node 中，最大化利用资源
2. 生成 pods
3. 专门运行在一个 node 上
4. Kube-apiserver: 暴露 k8s API，各个 service 之间交互用
5. etcd: 存 secert & config
6. kube-scheduler： assign new pod to available node, 更好的管理 space
7. Kube-controller-manager: logic handler
8. Cloud-controller-manger: 跟各个云服务 api 对接在 cluster level

### DevOps K8s Deep 2

Node:

1. == EC2
2. Node 是被 control panel 所管理的
3. 干活的，也叫做 worker node
4. 至少一个 pods
5. 至少一个 kubelet： 大脑和干活的之间的一个中介
6. 至少一个 container runtime：负责 running containers（implement container runtime interface 的都行）
7. Kube-proxy: network proxy 网管，负责管理 pod 之间的 IP 通信
8. 这里的 docker 负责管理每个 pod 的 container

K8s cluster:

1. 至少有一个 worker node
2. 里面的服务运行在多个 server 上（eg. Cm, ccm, api…），控制多个 nodes

Swarm：使用 docker CLI 生成 swarm，理解成轻量级，docker 原生 k8s

1. swarm == k8s cluster

- Kind: a tool for running local Kubernetes clusters using Docker container “nodes”. 主要用来测试 k8s 本身
- namespace == isolated logical project
- ingress controller == loader balancer

Swram 爬坑指南：

1. 版本，版本，版本！尽量和老师的版本一致，不然坑很多
2. k8s 用 1.21 的话，记得在 demojob 中 apiVersion: batch/v1beta1，否则使用 apiVersion: batch/v1 （我是升级到最新版本的 k8s 1.25 操作成功的）
3. 同理，kubectl -n create token admin-user 那里，如果使用旧版本的话，会报错命令不存在，无法直接生成 admin user token

### K8S basic components 1

![Untitled](<k8s_eks%20(5).png>)

![Untitled](<k8s_eks%20(6).png>)

![Untitled](<k8s_eks%20(7).png>)

![Untitled](<k8s_eks%20(8).png>)

- k8s benefits: high availability, high scalability and disaster recovery
- Pods
  1. abstraction over container
  2. each pod gets its own private IP address
  3. smallest unit
- service:
  1. provide the permanent IP address
  2. lifecycle of pod and service not connected; so when one fails, another one can connect directly quickly
  3. load balancer; send traffic to more pods
- internal service vs external service(public ip address with port in the node level): private IP vs public IP
- Ingress: a proxy(provides Public IP address) for external service → connect to service
- ConfigMap: external configuration of your application (the Pod actually gets the data that ConfigMap contains) such as url link (ENV)
- secret: used to store secret data without a plain text (ENV)
- volumes: consist save data (because K8s doesn't manage data persistence!)
- deployment:
  1. a blueprint for my-app pods (specify how many replicas and u can scale up or down)
  2. is a layer of abstraction on top of pods
- deployment for stateless Apps vs StatefulSet for stateful apps or DB

### K8s Basic components 2

![Untitled](<k8s_eks%20(9).png>)

![Untitled](<k8s_eks%20(10).png>)

- one node(slave nodes) must have: container runtime, kubelet, Kube proxy
  1. kubelet: interacts with both container and node; starting a pod with a container inside and assign the resource from node to the container (CPU, RAM)
  2. Kube Proxy: forwarding requests from services to pods (avoid network overhead of sending the request to another machine)
- Master nodes(control plane):
  1. API server: like a cluster gateway which gets the initial request of any UPDATE or QUERY; acts as a gatekeeper for authentication.
  2. scheduler: schedule new pod → api server → scheduler → where to put the pod (像行李打包，根据行李的 size 塞给不同的集装箱一样)； scheduler just decides on which Node new Pod should be scheduled. (具体由 kubelet 在每个 node 中去执行)
  3. controller management: detect any pods die in any nodes and reschedule those pods as soon as possible; (detects cluster state changes); controller manager → scheduler → kubelet; ensures proper STATE of cluster components.
  4. etcd: key-value store of a cluster state; cluster brain! 专门记录状态的；this storage cross all the master replica nodes.
     一般一个小型 cluster 有 2 个 master，3 个 slavor；
     master 需要较少的性能，slavor 需要较多的性能；
     master 和 slaveor 可以根据需求被无限扩展
- Slavor nodes:
  1. container runtime engine: Docker, containerd, CRI-O, frakti…
  2. kubelet: it is an agent that runs on each node in the cluster 确保每个运行没问题，并上报给 master，scheduler 也会通过这个来生成 pod
  3. kube-proxy(network proxy)： allows each node communicate with each other（allow network communications）

### K8s Services

![Untitled](<k8s_eks%20(11).png>)

![Untitled](<k8s_eks%20(12).png>)

![Untitled](<k8s_eks%20(13).png>)

![Untitled](<k8s_eks%20(14).png>)

- service will link it by selectors with each pod
- k8s creates an Endpoint object, which is the same name as Service and keep track of, which pods are the members/endpoints of the Service
- Headless service: only communicate with 1 specific Pod directly （ClusterIP: None）
- load balancer service is an extension of the NodePort Service
- NodePort Service is an extension of ClusterIP service

### K8s 常用 cmd imperative

1. kubectl edit pod redix: 修改已经创建的 pod 的 yaml 配置，进而修改构建 pod 的 image
2. kubectl run <tagName,自己起名字> —image=<docker image name> eg. kubectl run redis —image=redis 含义：create a new pod
3. kubectl delete pods <tagName> 删除某个 pod
4. kubectl get pods -o wide (get 一堆 pods，相当于 output，wide)
5. kubectl describe pod <tagName>
6. kubectl get pods
7. kubectl run redis —images=redis123 —dry-run=client -o yaml > redis.yaml 输出配置到 yaml 文件
8. kubectl apply -f <filename> 应用文件去生成 pods
9. kubectl create -f <filename> 生成
10. kubectl get replicaset： get command to see a list of replica sets created
11. kubectl delete replicaset <tagName>
12. kubectl replace -f replicaset <fileName> 替换配置
13. kubectl scale —replicas=6 -f <fileName>
14. kubectl edit replicaset myapp-replicaset 修改 replicaset 设置
15. kubectl scale rs new-replica-set —replicas=2 rs 是 replicaset 的缩写
16. kubectl get all 获得全部的详细信息，包括 deployment, replicas and pods.

Deployment strategy: create, get, update, status, rollback

![Untitled](<k8s_eks%20(15).png>)

1. kubectl rollout undo deployment/myapp-deployment 回滚部署的代码

— record=true 会记录命令的执行历史记录

1. kubectl set image deployment myapp-deployment nginx=nginx:1.18 更新 image

Service

1. NodePort: 让外部能够访问内部的，分 target port 和 port， nodeport
2.

![Untitled](<k8s_eks%20(16).png>)

kubectl get pods,svc 查看两个的在运行的服务

debugging:

kubectl logs {pod-name}

kubectl exec -it <pod name> —bin/bash

kubectl get deployment neinx-deployment nginx-deployment -o yaml > nginx-deployment-result.yaml 将配置信息拷贝到 yaml 文件中

'kubectl delete --all deployments --namespace=foo' 删除全部的 deployment, service XXXX

启动 type = loadbalancer 的 service 时，用 minikube service mongo-express-service 去暴露 external IP address

kubectl create namespace uat-petlover

### Volume

![Untitled](<k8s_eks%20(17).png>)

![Untitled](<k8s_eks%20(18).png>)

![Untitled](<k8s_eks%20(19).png>)

- persist volume PV: not in any namespace. they’re just available to the whole cluster to all the namespaces.
- persistent volume claim PVC: claims must exist in the same namespace as the pod using the claim
- storage class SC: provisions persistent volumes dynamically: when persistent volume claims it, SC generate directly
- configure and secret is local volumes(not in any ns) and it is not created via PV and PVC, which is managed by K8s

使用流程：

1. 老版本的：admins configure storage(Manually) ⇒ create PV ⇒ developer claim PV using PVC
2. 新版本 developer claim PV using PVC ⇒ Storage class SC allocate resources (PV) to developer

![Untitled](<k8s_eks%20(20).png>)

![Untitled](<k8s_eks%20(21).png>)

### Helm - Package Manager of K8s

![Untitled](<k8s_eks%20(22).png>)

![Untitled](<k8s_eks%20(23).png>)

![Untitled](<k8s_eks%20(24).png>)

![Untitled](<k8s_eks%20(25).png>)

- Helm Charts:
  1. bundle of Yaml files
  2. create your own helm charts with helm
  3. push them to helm repo
  4. use others ones
  5. helm hub, helm repo, helm pages
- templating engine
  1. define a common blueprint
  2. dynamic values are replaced by placeholders
- dev - staging - prod
- release management: state management in triller server(V2, V3 now is not exist)
- Helm command:
  1. 本地添加 helm repo：helm repo add bitnami https://charts.bitnamiXXXXXX
  2. 根据你添加的 repo 搜素需要的 application： helm search repo jenkins
  3. pull 下来一个 helm chart：helm pull bitnami/<image_name> —untar=true
  4. 安装 helm chart：helm install <give-a-name> bitnami/nginx
  5. 删除 helm chart 所部署在 node 中的 service：helm delete <give-a-name> (注意，此时，pod 中的 service 也会一并被删除)

### Namespaces in system

![Untitled](<k8s_eks%20(1).png>)

- Arch knowledge:
  1. deployment manage a replica set
  2. replica set manage all replica of its pod
  3. the pod is an abstraction of a container
- k8s namespaces
  1. a virtual cluster inside a cluster
  2. kubernetes-dashboard(namespace) only with minikube
  3. kube-system: system processes; master and kubectl processes; do not create or modify in kube-system
  4. kube-public: publicly accessible data; a configmap, which contains cluster information
  5. kube-node-lease: heartbeats of nodes; each node has associated lease object in namespace; determines the availibilitiy of a node
  6. default: resources you create are located here
  7. kubectl create namespace my-namespace
  8. create a namespace with a config file
     ![Untitled](<k8s_eks%20(2).png>)
- when to use multi namespace?
  1. resources grouped: db, monitoring, logging, elastic stack, nginx-ingress
  2. many teams with same application: each team working their own without influence each other
  3. resource sharing: staging and development
     ![Untitled](<k8s_eks%20(3).png>)
  4. blue/green deployment （reuse those components in both envs）
  5. resource limits; limited env; limit hardware resource (Each NS must define own configMap) (service can across NS)
     ![Untitled](<k8s_eks%20(4).png>)
  6. vol and node can not be inside the namespace(shared with others)
  7. add - -namespace=my-namespace to isolate each namespace
  8. 切换 ns
     1. kubectl config set-context $(kubectl config current-context) --namespace=test-ns 切换到 test-ns
     2. kubectl config set-context $(kubectl config current-context) --namespace=default 切换回 default

1. kube-node-lease: improves the performance of our node heartbeats (benefit for cluster autoscaling)
2. kube-public: readable for cluster
3. kube-system:
   1. kube-dns
   2. kube-proxy
   3. ebs-csi-node

### Probes

- liveness Probe
  1. kubelet uses liveness probes to know when to restart a container
  2. liveness probes could catch a deadlock, restart container
     "
     livenessProbe:
     exec:
     command: - /bin/sh - -c - nc -z localhost 8095
     initialDelaySeconds: 60
     periodSeconds: 10
     "
     'nc -z' will check if someone is listening on the other side
- readiness probe
  1. to know when a container is ready to accept traffic
  2. when is not ready, rm from load balancers based on this readiness probe signal
- startup probe：
  1. when a container application has started
  2. it will disable liveness & readiness checks first to avoid restarting container repeatly

### OIDC and IRSA with IAM identity federation

- To enable and use AWS IAM roles for Kubernetes service accounts on our EKS cluster, we must create & associate OIDC identity provider. Allow it to make calls to AWS APIs on your behalf.
  1. IRSA: IAM role service account （可以 associate 一个 IAM role 和一个 k8s service acount），这样，这个 service account 就可以提供 aws permissions to any 使用这个 service account 的 pods
  - To create and associate an OIDC identity provider with our EKS cluster, we need to follow these steps:
    1. Create an IAM OIDC provider in the IAM console.
    2. Associate the IAM OIDC provider with our EKS cluster.
    3. Create an IAM policy that allows our Kubernetes service account to assume the IAM role.
    4. Create a Kubernetes service account that uses the IAM role.
    5. Verify that the Kubernetes service account can assume the IAM role by running a test pod.
  2. OpenID connect provider: EKS 作为一个 provider，可以使用 aws EKS open id connect provider to access AWS services using the IAM identity federation
     ![Untitled](<k8s_eks%20(53).png>)
     [https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html)



### DevOps CDN&DNS

![Untitled](Untitled%208.png)

![3693b95f250de356d9af95d8789e589.png](3693b95f250de356d9af95d8789e589.png)

![Untitled](Untitled%209.png)

CDN(Content Delivery Network) == AWS CloudFront:

1. low latency: distributed content to a globally-distributed network of proxy servers/locations local server by caching, such as S3 static resources, which copies content from the original server.
2. high availability:
   - avoid single point of failure: if one server node failed, all the services will be down.
   - avoid DDoS(Distributed Denial of Service) Attack
3. The application needs to CDNify via file versioning. Otherwise, it needs time to update(数据延迟 )

so it can reduce bandwidth consumption, secure the original server

DNS(Domain Name System) == AWS Route 53:

The **Domain Name System(DNS)** is the hierarchical and decentralized naming system used to identify computers reachable through the Internet or other Internet Protocol networks.

(多级查询，最终返回目标 server 的 IP 地址)

DNS Host: 相当于本地的电话本，当我们访问一个新的域名，电脑会优先在自己的 host 中查找 domain name 所对应的 ip address。如果找不到，则会通过 DNS 去寻找 domain name 对应的 ip address

ps: 当我尝试在没有 certificate 状态下用 http 去连接，会报错图四，即仅支持 https

#澳洲 IT #DevOps #澳洲求职 #澳洲找工作 #程序员 #转码

### 高频面试题

![structure.png](structure.png)

TLD (Top-Level Domain, 顶级域名)

SLD (Secondary-Level Domain, 二级域名)

经典面试题：当输入域名后，发生了什么？

1. 浏览器查询浏览器的 DNS 缓存
2. if not, 查询本地客户端(本地局域网/zone)host 文件的对应的 IP 地址
3. if not, 查找运营商（root name server）提供的 DNS 服务器，是否有对应 DNS 缓存
4. if not, 向根服务器查询，进行递归查找 （从顶级域名开始 e.g. .edu ⇒ washington ⇒… 一步步缩小范围，最终客户端取得 IP 地址）
5. 获得 IP 地址后，进行 http/https 请求，客户端与服务器三次握手
6. http 请求包包含 head, body。head 中包括对请求文件操作的信息，body 中包括 payload/data
7. 服务器收到 http 请求后，进行负载平衡等后端流程
8. server return head + response
9. client(chrome) render data

### DevOps DNS Record

![Untitled](Untitled%2010.png)

### **DNS 域名解析中添加的各项解析记录**

- A：将域名指向一个 IPv4 地址（例如：11.11.11.11）
- CNAME：将域名指向一个域名，实现与被指向域名相同的访问效果，需要增加 CNAME 记录。这个域名一般是主机服务商提供的一个域名
- MX 记录：建立电子邮*箱服务，将指向邮*件服务器地址。
- NS 记录域名解析服务器记录，如果要将子域名 specific 某个域名服务器来解析
- TXT 记录：optional。一般做一些验证记录，安全时会使用此项，如：做 SPF（反垃圾邮\*件）记录
- AAAA 记录：将主机名（或域名）指向一个 IPv6 地址（例如：ff03:0:0:0:0:0:0:c1）
- SRV 记录：添加服务记录服务器服务记录时会添加此项，SRV 记录了哪台计算机提供了哪个服务。格式为：服务的名字.协议的类型（例如：\_example-server.\_tcp）。
- SOA 记录：SOA 叫做起始授权机构记录，NS 用于标识多台域名解析服务器，SOA 记录用于在众多 NS 记录中那一台是主服务器
- PTR 记录：PTR 记录是 A 记录的逆向记录，又称做 IP 反查记录或指针记录，负责将 IP 反向解析为域名
- 显性 URL 转发记录：将域名指向一个'http(s)'协议地址，访问域名时，自动跳转至目标地址。例如：将 heixuanfeng dot cn 显性转发到 likui dot com 后，访问 heixuanfeng dot cn 时，地址栏显示的地址为：likui dot com。
- \*隐性 UR 转发记录 L：\*\*将域名指向一个'http(s)'协议地址，访问域名时，自动跳转至目标地址，隐性转发会隐藏真实的目标地址。例如：将 heixuanfeng dot cn 显性转发到 likui dot com 后，访问 heixuanfeng dot cn 时，地址栏显示的地址仍然是：heixuanfeng dot cn。

Zone: Zone is collection of nodes (sub domains) under the main domain. The server maintain a database called zone file for everyzone.

#澳洲 IT #DevOps #澳洲求职 #澳洲找工作 #程序员 #转码

CDN record: [https://cloud.tencent.com/developer/article/1537894](https://cloud.tencent.com/developer/article/1537894)

AWS 文档：[https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/ResourceRecordTypes.html)

Route 53 Alias: [https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-choosing-alias-non-alias.html](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-choosing-alias-non-alias.html)


CDN&DNS


### DevOps Linux System 01

- Azure 中的 resource group 可以理解成 GCP 中的 project： a container for a project related on project reources. (based on business logic)
- RedHat vs CentOS vs Debian vs Ubuntu
  1. Ubuntu: 带界面
  2. Debian: 比 Ubuntu 稳定，小 size，就系统本身，固若金汤
  3. RedHat：黄金企业版，贼贵
  4. CentOS：RedHat 对应的开源版本
- apt 相当于一个 index，连接不同的版本 repo，apt update 能更新目录索引
- ～/.jenkins 中可单独 archive 用户文件,JENKINS_HOME → default：/var/lib/jenkins
- keep the same number of CPUs ⇒ of executors (total number of concurrent job)
- SCM: source code mangement → 从 version control 中去拉取

### DevOps Linux file struct 02

![d0c50-linux2bfile2bsystem2bhierarchy.jpg](d0c50-linux2bfile2bsystem2bhierarchy.jpg)

- **/bin, /sbin, /usr/bin, /usr/sbin**:  这是系统预设的执行文件的放置目录，比如  **ls**  就是在  **/bin/ls**  目录下的。
- 值得提出的是  **/bin**、**/usr/bin**  是给系统用户使用的指令（除 root 外的通用用户），而/sbin, /usr/sbin  则是给 root 使用的指令。
- **/var**：  系统上跑了很多程序，那么每个程序都会有相应的日志产生，而这些日志就被记录到这个目录下，具体在 /var/log  目录下，另外 mail 的预设放置也是在这里。
- /var 包含系统一般运行时要改变的数据。通常这些数据所在的目录的大小是要经常变化或扩充的。原来 /var 目录中有些内容是在 /usr 中的，但为了保持 /usr 目录的相对稳定，就把那些需要经常改变的目录放到 /var 中了。每个系统是特定的，即不通过网络与其他计算机共享。
- /etc 目录包含各种系统配置文件，许多网络配置文件也在 /etc 中。

### DevOps Linux sudo vs su 03

![95e72e18d4c703f711599198dea084c0.webp](95e72e18d4c703f711599198dea084c0.webp)

- su 和 su - 的区别：su 只是切换了 root 身份，但 Shell 环境仍然是普通用户的 Shell；而后者连用户和 Shell 环境一起切换成 root 身份了。只有切换了 Shell 环境才不会出现 PATH 环境变量错误。su 切换成 root 用户以后，pwd 一下，发现工作目录仍然是普通用户的工作目录；而用 su -命令切换以后，工作目录变成 root 的工作目录了
- sudo vs su: sudo == super user do; su = swith user
  1. su 默认切换到 root 用户
  2. su - -c 临时借用 root 用户的权限，执行完后返回当前用户
  3. sudo su - == sudo -i 切换到 root 用户（以 login shell 的方式切换到 root 用户），其中，sudo su - 需要提供当前用户的密码，su - 需要提供 root 用户的密码
  4. 一个用户能否使用 sudo 命令，取决于 root 用户在/etc/sudoers 文件中是否给了授权，只有 root 用户有权使用 visudo 命令。
- [root@localhost ~] 代表着：
  1. 用户名：root
  2. 主机名：localhost
  3. 当前路径：~当前用户的 home 目录
  4. 权限标志位：#代表 root，$代表普通用户
- [root@localhost ~] 中，~ 和 /的区别
  1. 第一个是 root 的主目录，相当于 Windows 下的 C:\Documents and Settings\Administrator 这个目录一样，第二个是 Linux 的根分区，相当于 c:/。
  2. 在根目录下，有/root 目录和/home 目录，像 root 用户的主目录是/root,其它用户的主目录一般是/home/username

### DevOps Linux Cron Job

![Untitled](Untitled%2038.png)

![Untitled](Untitled%2039.png)

- set -x 开启 +x 关闭: 用于输出详细日志，是 Shell 脚本中使用 echo 命令输出的替代方案。
- echo $? : check 上次的指令是否成功。成功返回 0，否则返回 1
- 查找文件及内容
  1. 'grep "被查找的字符串" 文件名' **从文件内容查找匹配指定字符串的行**
  2. 'grep –e "正则表达式" 文件名' 文件内容查找与正则表达式匹配的行
  3. 'grep –i "被查找的字符串" 文件名` 不区分大小写
  4. 'find / -name "\*.log" | xargs grep "ERROR"' 从根目录开始查找所有扩展名为 .log 的文本文件，并找出包含 "ERROR" 的行
- 管道
  1. | : 当一个命令无法完成时，多个管道命令结合
  2. | xargs：当管道后面接的是文件名时
- 定时任务
  1. crontab -e 设置定时任务
  2. crontab -l 查看定时任务
- 拷贝文件从本机到 remote server(安全状态下)

  1. scp -i ~/.ssh/key.pem <从文件 newfile> ec2XX@<public IP>:<route path>

     eg. scp -i ~/.ssh/my-key.pem newfile ec2@53.33.33.33:/home/ec2-user/newfile
     从远程拷贝文件到本机，反之亦然。可用**FileZilla 传输**

- 设置文件所有者 sudo chown <username>:<group username> <fileName>
- 查阅正在改变的日志文件 tail -f filename (-f 循环读取)
- PID：process identification 进程标识号，在操作系统中创建时自动分配给每个进程的唯一标识号
- 应用的可执行文件：把执行文件启动在操作系统中形成一个应用的副本，这个副本就是进程，即进程是应用的执行副本
- 较好的查看文件内容命令 less （觉得没啥用 😂）

#澳洲 IT #DevOps #澳洲求职 #澳洲找工作 #程序员 #转码

[https://crontab.guru/](https://crontab.guru/)

### DevOps Regrex 备忘录

正则表达就是学了就忘系列，我是记不住 =。=

- ^： 从某个 letter 开始
- $： 以 XXX 结尾
- \*：≥ 0
- +：≥1
- ?：[0, 1]
- x{n}：x 出现 n 次
- x{n,}：x 出现的次数 ≥n
- x{n, m}：x 出现的次数 ≥n, ≤m
- ()：看作一个整体
- []：or 集，出现其中一个即可
- \d：单数字
- \w：单 character，eg letter, numbers, underscore
- \s：单空格，tab 和 line break
- \1: eg /(x)(y)\1/ ⇒ /(x)(y)(x)/ 反向引用括号里 pattern 的内容，按照顺序

\D, \W, \S 为非小写的集合

- Flags 在/patterns/的结尾
  1. g: 全局搜索，否则只返回 first match
  2. m: 多行匹配
  3. i：regular expression case insensitive

### DevOps Mac && Linux 环境变量 | Day

![Untitled](Untitled%2047.png)

![Untitled](Untitled%2048.png)

- sh 一般指的是 linux 的，但在 Mac 上的 sh 指令指的不是这个（William 老师认为这个的兼容性更好）
- bash 是 sh 的扩展，mac 中的 sh 和 bash 指的都是这个
- 环境配置
  1. /etc/profile 第一个被加载，对所有用户起作用，权重最低（不建议修改此文件）
  2. /etc/paths 全局环境变量配置文件
  3. ～/.bash_profile → ~/.bash_login → ~/.profile → ~/.bashrc 读完系统文件后会读取这个文件，如果找到 bash_profile，就不会找后面的文件，linux 的顺序可能不同
  4. ~/.zshrc 这个是装了 oh-my-zsh 后的，系统从 zsh 启动，读取～/.zshrc，不会读取～/.bash_profile 文件了，可在文件最后添加 source ～/.bash_profile 来额外读取一次 bash 的配置
- source ～/.bash_profile 重新激活一次配置文件环境变量
- export ZSH=$HOME/.on-my-zsh 导出环境变量，可通过 echo $XXX 查看 export 出来的信息
- PATH=$PATH:HOME/bin 这种冒号的是在原来的 PATH 上额外添加，冒号允许多个 PATH 路径，在执行的时候去各个文件夹去找
- 如果不添加在配置文件中，直接在命令行中输入 export XXX，则仅在当前用户执行，重启后消失（用户级全局变量）
- alias ll = ‘ls -lt’ 命名快捷键 （可以打 alias 直接查看其同存储的 alias）
- env 直接查看所有环境变量
- echo $PATH 直接查看某个环境变量

- Linux 链接命令
  1. & 任务在后台执行
  2. && 前一条成功后，才执行下一条命令
  3. | 上一条命令的输出作为下一条命令的输入
  4. || 上一条命令执行失败后，才执行下一条命令参数
- Linux io 三剑客：stdin, stdout, stderr 等价于 python 的 input, print, (没有对应)
- 去两边字符 sed -e 's/[[:space:]]_$//' | sed -e 's/^[[:space:]]_//'


AWS Identity and Access Management(IAM), Elastic Compute Cloud(EC2), S3, VPC, NAT Gateway, NAT Internet

Linux


### Jenkins VM server 安装流程整理 (之后用 Ansible 安装)

- 安装 VM Jenkins
  1. 更新 apt
  2. 安装 java 环境
  3. import the GPG key for the Jenkins repository
  4. add the Jenkins repository to the system
  5. Once the Jenkins repository is added and enabled, you can update the package list and install the latest version of Jenkins by typing
  6. apt install Jenkins: 'sudo apt install jenkins -y'
  7. check Jenkins status: 'systemctl status jenkins'
  8. 开通 8080 端口 (gcp 这里比较麻烦，要新建 port 在 gcp Firewalls，然后根据 tag 应用到（attach）到 gcp vm 上)
  9. 从 vm 中拷贝 key 'sudo cat /var/lib/jenkins/secrets/initialAdminPassword'
  10. sudo -i ⇒ root user ⇒ gpasswd -a jenkins root (将 jenkins 账号添加在 root 中)
  11. groups jenkins 应该显示 root
  12. visudo ⇒ add jenkins ALL=NOPASSWD:ALL 用户可以在不输入密码的情况下，jenkisn 可以使用系统级命令权限（eg. docker）
  13. 'sudo usermod -aG docker $USER' dial unix /var/run/docker.sock: connect: permission denied 解决办法，Jenkins docker 无权限运行 docker 的情况 (add jenkins to docker group)
      Linux，默认是 home/user 是默认路径目录，而 jenkins 的 home 目录是在 var/lib/jenkins，所以很多需要 jenkins 执行的命令，都需要安装在这个目录的名下，例如 github .ssh
  14. 切换到 jenkins 用户后，'ssh-keygen' 生成 github access key
  - 用于主，nodes 联动
  1. ssh-keyscan -H ip-address >> /var/lib/jenkins/.ssh/known_hosts 省去 yes 的认证步骤， optional，，会把这条记录加到 known_hosts
  2. 把 public key 给 master，放到 authorized_keys 中 echo “content” >> ~/.ssh/authorized_keys

### Jenkins 可以存储以下类型的 credentials:

- Secret text - API token 之类的 token (如 GitHub 个人访问 token)
- Username and password - 可以为独立的字段，也可以为冒号分隔的字符串：username:password(更多信息请参照 处理 credentials)
- Secret file - 保存在文件中的加密内容
- SSH Username with private key - SSH 公钥/私钥对
- Certificate - a PKCS#12 证书文件 和可选密码
- Docker Host Certificate Authentication credentials.

### Jenkins Plugins Required

- AnsiColor: coloring the Console Output
- Blue Ocean:
- pipeline: AWS steps
- \***\*CloudBees AWS Credentials: 存 access key 和 secret key 的\*\***
- CloudBees Docker AWS Credentials
- Role-Based Authorization Strategy
- Email Extension Plugin
- docker
- docker pipeline
- Bitbucket Plugin
- Slack Notification Plugin

- Azure Credentials plugin

### DevOps Jenkins 01

![IMG_0394.PNG](IMG_0394.png)

![IMG_0395.PNG](IMG_0395.png)

- Jenkins
  - an open-source application that allows CI&CD, which can be integrated with a number of testing and deployment technologies.
  - improve efficiency: CD with a web project ⇒ web farm (web server farm), which can be checked easily from the dashboard (to check CD status).
- CI
  - By automatically verifying the build using unit tests and packaging the solution for each new code changes are submitted
  - compile == Build == CI (codes(source code/text file) to binary) ⇒ .exe, lib, pkg
- CD
  - takes executable files(validated code package) from the build process and deploys them into staging or production env.
  - developers can track which deployments were successful or not and narrow down issues to specific package versions
  - 两组 severs 从 staging 到 production 交替部署(见图), blue/green deployment
    [https://blog.inedo.com/blue-green-deployment-best-practices](https://blog.inedo.com/blue-green-deployment-best-practices)
    也可用 Jenkins 去调度其它云服务资源，如 AWS CodeBuild/CodeDeploy。个人觉得是一种资源补充吧
    因为 M1 使用的是 ARM 架构精简指令集，运行 docker 大概是使用 Rosetta2 转译，机器运行 Jenkins 在 docker 中感觉奇慢无比，目测慢于 10 倍 Win

### DevOps Jenkins&内网穿透 02

![Untitled](Untitled%2022.png)

- install Jenkins locally
  - In win, sudo service dock start : 以启动 ubuntu docker engine（可以关联 docker engine 到 ubuntu (入图 2)
  - 运行 Jenkins container
  - get admin password to finish build jenkins
- ngrok 内网穿透（反向代理）
  - 访问 ngrok 官网，获得 auth-token
  - 本地安装
    - for win, 改权限 → 解压 → 配置 token → 开放 80 端口
    - for mac, 可以使用 brew install —cast ngrok （没有自己去.bash_profile 配路径的烦恼），其余的和 win 一样
    - copy 内网穿透地址到 Jenkins configuration → Jenkins URL
- 联动 Github with Jenkins
  - add new item
  - freestyle project
  - with git + Repo URL with .git connection
  - build triggers → Github hook trigger for GITcm polling
  - braches to build 可以选择\*/master or/and null mean all branches trigger
  - 在 github 中添加 webhook → go to git repo
  - payload URL 注意结尾一定要是 github-webhook. eg. http://XXXXngrok.io/github-webhook/
  - just the push event(trigger situation)
  - active (激活改 webhook)

win&ubuntu 用户需要在各种命令前加上 sudo

安装 ngrok 在 osx

[https://gist.github.com/wosephjeber/aa174fb851dfe87e644e?permalink_comment_id=3621858](https://gist.github.com/wosephjeber/aa174fb851dfe87e644e?permalink_comment_id=3621858)

### DevOps Azure Docker Jenkins 1

- create VM
  1. 在服务器中查看 connection
  2. 给端口 22, 80 和 433
  3. 给 ssd 64g，勾选同步删除 及 同步删除 public IP
  4. 开放 8080 端口 for demo
- ssh server → install Jenkins docker
  1. sudo apt update
  2. sudo apt install docker-compose
  3. sudo docker run XXX
- NS delegation from AWS to Azure - subdomain
  1. nslookup -type=NS [shawnwong.click](http://az.shawnwong.click) check DNS Name server
  2. add the domain name in Azure DNS (eg. sure.XXX.XXX)
  3. copy NS from Azure DNS to the domain server in NS (NS delegation)
  4. nslookup -type=NS nz.[shawnwong.click](http://az.shawnwong.click) check DNS Name server
  5. add a new record set in Azure DNS with type A and alias
- install nginx in Azure VM
  1. apt install nginx
  2. systemctl enable nginx (配置开机自动启动)
- add SSL
  1. modify nginx files
  2. restart nginx: sudo systemctl restart nginx
  3. systemctl status nginx 查看某一个服务的运行状态

坑：

- wsl 的 ubuntu 无法修改 win 文件的权限，编辑或创建
  1. 可直接拷贝文件到 linux 目录下 cp
  2. 直接修改/etc/wsl.conf 文件权限

### DevOps with Private Github 2 & Nginx Config

![Untitled](Untitled%2027.png)

![Untitled](Untitled%2028.png)

![Untitled](Untitled%2029.png)

![Untitled](Untitled%2030.png)

配置指定域名 DNS(from AWS to Azure)

- 在 Azure DNS 中创建， Name 可填写为 XXX.<urdomainname>
- copy NS name 到 AWS route53 delegation
- 创建 record set → 用 alias recoder set 可直接指向到 vm server 资源
- or 直接用 A 标签指向 public IP address

Install Nginx & add cert to Jenkins server：

- sudo apt install nginx
- sudo systemctl enable nginx: 开机自启动
- 添加证书
- sudo systemctl status nginx 查看某一个服务的运行状态
- sudo systemctl restart nginx 重启 nginx

Narrow way to add ssh public key

- add ssh key in specific GitHub repo → setting → deploy keys to let user only access this repo

爬坑指南：

1. 如果是 docker 运行的 jenkins，添加.ssh 记得要在 docker 内添加（使用 sudo docker exec -it <cont_id> sh 进入 container 后，再使用 ssh-keygen）
2. 不需要在 jenkins 中添加添加 confidential，即在 dashboard-<your-pipelineName>-source code management 中，credentials 选择 none
3. 可 restart container with the command：sudo docker restart <Con_id>
4. 修改 nginx 配置文件时，记得 comments 掉 404 指向

### DevOps Jenkins Ocean Blue

![Untitled](Untitled%2031.png)

- 主要包括 CI 和 CD（content delivery）的 multibranch pipeline，未包括 content deployment
- content deployment 主要涉及一些生产环境的 data（用户信息，database），live workloads
- git push origin <new-branch> or git push origin HEAD 推送新的 branch 到 github 上
- git pull . master 把文件从 master pull 到当前的分支（自己自动同步了本地）
- Plugin 和 Docker Engine 的区别？
  - 一个是使用 docker 的工具，一个是 docker 本身 —Arno
- Ocean Blue 使用流程
  1. 链接 github → github setting → developer setting → personal access tokens → 给予权限（user, write…）→ create a pipeline
  2. Install docker-engine in Linux
  3. which docker → 在这里面找到 docker engine 路径，然后添加到 global config
  4. config docker path in Jenkins and add Jenkins plugin with docker pipeline and docker plugin
  5. add HOME ’.’ in Jenkinsfile 在当前 user 的文件夹下去运行这些文件（/bin/sh），而不是 root 文件下(cd.. to root)

### DevOps Jenkins master-nodes 联动

![Untitled](Untitled%2040.png)

AZ-GCP-Local Jenkins

- 启动 AZ， GCP VM + local machine
  1. 添加 docker 环境
  2. 添加 JDK 11+ 环境
- 添加本地 node： manage Jenkins → manage nodes and clouds → add a new node
  1. 注意在 configure global security 中添加 fixed TCP port 5003
  2. wget jar 包到本地 machine
  3. 开放 inbound 5003 在 AZ VM
  4. 因为是 local，会 offline，选择 label 名字匹配的时候才启动
  5. 选择 launch agent by connecting it to the controllor (由 AZ VM 主动去 call local machine 去执行 task)
- 添加 GCP node
  1. 'visudo' 命令是**用来编辑修改'/etc/sudoers' 文件，为普通用户配置'sudo' 权限的（修改 jenkins 到普通用户可操作， 使 Jenkins 在不输入密码的情况下可进行一些操作）jenkins ALL=NOPASSWD:ALL**
  2. 尽可能多的使用该 node
  3. /var/lib/Jenkins 相当于 jenkins 这个用户， 跟 root/用户名类似
  4. 给 Jenkins 这个‘用户’生成 ssh key：/var/lib/jenkins/.ssh/id_rsa
  5. ssh-keyscan -H 34.129.185.248 >> /var/lib/jenkins/.ssh/known_hosts 添加 GCP node 主机到可信列表
  6. [添加 id_isa.pub](http://添加isa.pub) key 到 gcp 中，方便无密码访问 echo ‘keyxxx’ >> ‘ssh-rsa public key’ to ~/.ssh/authorized_keys
  7. 添加 id_rsa private key 到 jenkins credential 中，完成和 gcp VM 的认证交互

### Jenkinsfile Generator

![Untitled](Untitled%2041.png)

![Untitled](Untitled%2042.png)

![Untitled](Untitled%2043.png)

Jenkinsfile 可以用 Jenkins 自带的代码流程生成器去生成代码，其中包括 snippet generator 和 declarative directive generator.

- pipeline: code pipeline start
- agent
  1. any: any agent
  2. label: run on an agent matching a label
  3. docker: run inside a docker container
  4. dockerfile: build on an image matching a label
- stages: pipeline start point
- post: execute some logic after all stages are executed (可用于根据不同的执行情况做最后的内存处理)
- parameters

Snippet Generator

- cleanWs(): delete workspace when build done
- git: git credential
- timeout + input:

爬坑指南：

1. 在 snippet generator 中生成 withCredentials，这里的选择 username 和 password(separate)的，然后链接的是自己在 jenkins 中设置的 username 和 password，同时，这里命名的 dockerPwd 在 jenkinsfile 中，会反向匹配，最终应用在命令行中，起到了一个密码保护的作用
2. credentialsId 即是自己在 jenkins 中起的名字
3. parameters 的话，会出现在 jenkins 中， BUILD WITH PARAMETER，对 pipeline 进行空参执行


Jenkins CI/CD

Jenkins


![Untitled](Untitled%2072.png)

### DevOps Terraform Basic 1

- infrastructure as code?
  1.  用代码生成硬件资源 （Create, Update(Change), Destroy (CUD)）(Terraform)
  2.  deploy/update applications on top of the infrastructure
  3.  manage the configurations used by the applications (Ansible)
- terraform vs ansible
  1. terraform: 负责 infrastructure
  2. ansible: 负责 config that infrastructure
- terraform：核心组件一 → input sources
  1. core：TF-config that what to create/configure?
  2. state: snapshot 当前 infrastructure 状态
     core compare both → plan: what needs to be CUD? 根据 desired config 去修改当前的状态
- terraform: 核心组件二 → main components
  1. providers：各种云，k8s, service
- declarative vs imperative?
  1. declarative: 来个 cheese buger 🤓Terraform
  2. imperative: 一步步指导怎么做（烤面包，煎肉，拿芝士。。。）
- acl: access control list 权限管理列表
- 使用 HCL（Hashicorp Configuration Language）语言
- init → plan → apply → destroy

### DevOps Terraform 2

![1605496195438-image.png](1605496195438-image.png)

- VPC spans all the AZ(subnet) in the region 就是一个 region 有很多 VPC，每个 AZ 中有对应的 subnet
- subnet level control ⇒ NACL
- instance level control ⇒ security group
- Terraform
  1. source: create new cloud resource
  2. data: get known resources already from the cloud
  3. provider == import library
  4. resource/data == function
  5. tags = {Name: XXX} 注意，这里的 name 只有是开头大写的情况，才是修改 vpc 的 Name 属性
  6. terraform destroy -target aws_subnet.dev-subnet-2 删除指定 resource
  7. terraform apply -auto-approve 自动认可变化更改的类型
- terraform state
  1. list: 列出该状态下的所有资源
  2. show <resource>
- terraform variables:
  1. params 的形式
  2. command line 输入的形式
  3. terraform.tfvars file to record variables
  4. export TF*VAR*<variable_name=”Oldiron666”
- terraform 多环境部署？
  1. 创建不同的 terraform.vars 文件 eg. terraform-dev.tfvars
  2. terraform apply -var-file=”terraform-dev.tfvars”
  3. 先切换工作目录/环境 terraform workspace new uat
  4. terraform apply -var-file=uat.tfvars 或者 terraform apply -var-file=.tfvars
  5. 此时，S3 会生成一个.env 的环境，自动很好的帮我们 organize 多环境问题

### DevOps Terraform 3

- 知道为啥 Sydney 有三个 sub-vpc 不？ 一个 AZ 一个呀！
- NACL： 防火墙对于 subnet 来说，默认是 open
- Security Group：针对 server 来限制，默认是关闭的
- route table： like roads, the traffic within a private VPC
  1. local = within the VPC
- 无论 internet gateway 还是 AWS route table,都是虚拟的！
  1. Internet gateway == virtual modem
  2. route table == virtual router
- The procedure connects the network for VPC
  1. vpc
  2. Internet gateway
  3. route table
  4. connect route table with the internet gateway
  5. connect route table with subnet (subnet association) (the traffic in the subnet can be handled by the routeing table)
     attention: 如果没有指定 subnet association，会自动分配默认的子网
- 关于秘钥问题的一点猜想 ssh key

  1. github 的时候，是提供了自己的公钥到 github 中
  2. aws 下载的秘钥，是私有 key
  3. 用自己的 ssh key 链接时，也是先用 public key 发给 aws，然后用自己的私有 key 登录
     可以说是先非对称加密，后对称加密的代表了。public key 用于传输，private 用于解密。另外，ssh 默认使用 private key 链接，直接 ssh <connectionString> 省时省力。
     ps：
     第一次认证的时候，需要加入到 known_host 中，问你是否 yes

### DevOps Terraform final

- Modules: 就像编程中的 func 一样，封装代码，提高代码的复用率。一个 module 中，至少组合> 3 个以上的 resources
  1. root module
  2. /modules = “child modules” which is called by another configuration
- input variables == function arguments
- output values == function return values
- external terraform 使用 source 去判断 module 的来源 ）（we use source to add path for our local module）
- configure a remote backend to safely store and share terraform state by S3
  1. 所有的状态修改会被直接上传 S3
  2. terraform state list 可以直接远程链接 S3，查看已经创建，使用的资源

然后我就干了件蠢事儿，把上传到 S3 的 state 文件，手动删了 导致已经被创建的资源需要手动删除了。。。。

- handle version and shared storage for state
  1. S3 for shared storage for state files
  2. Dynamodb for version locking
- 坑
  1. terraform 的配置主要是在 backend 那里设置的，配置好要先 init
  2. S3 和 Dynamodb table 需要手动创建后，再在 backend 里面添加 S3 和 dynamodb_table 名称（引用），不然会直接从 aws 云服务中找，会找不到
  3. 如果自动创建 S3，dynamodb 的话，destroy 的时候会一并干掉，奇葩的设定。。。

缺点：觉得 terraform 还是个不成熟的产品，但是理念很不错。variable 层层传递问题，state 和 lock 文件的保存问题，都让人觉得非常不合理。

### DevOps Terraform 前端爬坑

- 前端分为 s3, cdn, acm 和 route53
  1. s3 的难点可能在于从 aws_iam_policy_document 中拿 policy，这个 policy 是只能 cdn 通过 oai 访问 s3 的 getobject 方法；且是通过 data 的形式拿到的，这个 data 的参数是不能通过 module 里 outputs 的形式返回到外面的，所以只能放到 root，main 中去写。
  2. route53，因为我的 domain 在另一个 aws 账号，所以只能提前 delegate 过去，用 data 的形式拿到 zone id 后，再去处理；另一个点是和 cdn 联动，因为是 s3 → cdn → route53，所以 route53 主要是从 cdn 拿数据，通过 alias 的方式。同时，route53 会创建一个 CNAME 去验证 acm 证书的有效性
  3. cdn 在链接 route53 的同时，需要验证 acm_certificate 的有效性。在 view_certificate 中，仅仅给了 acm_certificate 还是不够的，根据文档，需要添加 ssl support method 模式，这里选的是 sni-only，用默认的“TLSv1”的协议版本就可以成功选择我们为域名生成的证书了，这里算是比较深的一个坑。
  4. acm 的一个坑主要在创建的 region。如果需要被 cloudfront 链接认证，acm 必须创建在 Virginia，也就是 us-east-1。整个前段其实可以基本无视 region 的限制，因为 s3 的数据是被加速到全球 cdn 的（当然可以自己选择覆盖的区域），如果考虑创建多个资源在不同的 region，在 module 子资源中，需要创建 provider，指定 region 和 alias，然后创建 mult-region 的资源中添加 provider=aws.<aliasName>去引用资源。而且在 resource 中的 provider argument 是没有标注的，我在自己尝试中发现可以指定，算是一个小坑。
  5. 最终，我的 route53（acm_certificate_validation，没错，我把它放到 route53 module 了，因为我认识是 route53 在对其进行验证） 和 acm 都是新建在 Virginia

### DevOps terraform 多环境 + ECS 理论

- Terraform
  1. terraform fmt -recursive 统一 format 所有文件
  2. 应用部署不同的环境 terraform apply -var-file=”<dev/pro>.tfvars”
  3. manage multi env + multi workspace ⇒ terraform workspace 创建不同的 workspace 用于跑 dev 和 prod 环境
  4. provider “aws” { profile = “XXX”} 这个 profile 主要用来匹配存在电脑中的 credentials’ access_key_id and secret_access_key.
  5. terraform init -backend-config=”dev-backend.conf”
- ECS Fargate
  1. task definition: describes one or more containers through attributes, which combines multiple container definitions. (task definition combines multiple container definition)
     1. 也包括了 container definition： container image and container level setting(port, registry, env variables)
  2. cluster: fully managed by AWS
  3. service: allows running and maintaining a specified number of simultaneous instances of a task definition（task） in an ECS cluster. 定义 task 的数量
  4. task: 从 task definition 中实例化

### DevOps tf-backend 小记

![Untitled](Untitled%2076.png)

- 为什么 application load balancer 要设置 sercurity groups 和 listener 两层限制?
  我目前的猜测是：首先 loader balancer 的实现是使用 ec2，ec2 就会有 sg 的概念，允许哪些端口流量进入 serve。同时 server 中会安装类似于 nginx 的软件，进而实现负载平衡，而这个软件需要设置开放的端口配置流量。此外，一般是同时设置 listeners 和 routing，就是接到这个流量后发送的 destination。相当于 aws 把软件的配置抽象出来，给客户更好的 UI 来实现对软件的配置
- apt remove: 会删除软件包而保留软件的配置文件
- apt purge: 会同时清除软件包和软件的配置文件
- IAM role
  1. similar to an IAM user but unlike a user who is associated with one person. a role is intended to be assumed by a user or a service or an application.
  2. a role does not have credentials such as a password access key.
- IAM user：1 user → _ groups. 1 group → _ users
- cf, tf, aws cdk & pulumi:
  1. CloudFormation 跟 tf 是一样的 都是 declarative syntax，只不过是用 yml 写的
  2. aws cdk 跟 pulumi 是一样的 用任意编程语言生成 infras
- 坑：
  1. lb 的 enable_deletion_protection = true，会阻止 destroy lb，改成 false，在 aws 中才能被自动 destroy 掉，但是 tutor 不建议可以被自动 destroy
  2. ecr_repo 默认是在 private 里找 image，public 中找不到
  3. ecr 的命名要全部小写
  4. ecr 尽量放在 private 中

### DevOps AWS 后端小记 | Day

![1cf0c8732975a2d7c01779df01d7a97.jpg](1cf0c8732975a2d7c01779df01d7a97.jpg)

![41d57fdd2b81731fbeeb74d5cba6125.jpg](41d57fdd2b81731fbeeb74d5cba6125.jpg)

- 可以公开的情报
  1. AWS cdk 编译后，生成的是 cloudformation
  2. VPC peering: 让两个子网的 resources 进行沟通
  3. least priviledged model: 只给服务必要的端口权限，即便是同一个 private subnet 中。如果某个自服务被黑客攻击了，也无法访问其它的服务
  4. each private has one NAT
  5. a public subnet can share one NAT
  6. 如何提现 security 的 stateful？ 只要能进来，就能出去。stateless 的是 NACL
  7. elb 的 target group 的 port，为啥可以随便写？答：这个端口是 elb 从 listener 到 target group 所进入的端口，是 target group 的入口端口，所以可以随便写（别占用系统默认的开放端口就行）
  8. tf 中，ecs 的 container 可以关掉 assign public ip address，因为没什么卵用
  9. tf 中的 sg 的 ingress，from_port 和 to_port 指是一个 port 范围，eg. 666~777. 我们目前写的两个值相同，则是只开放一个端口。
  10. sg 中，一般只定义 ingress 的开放端口；egress 是全部开放的，eg. 1~65535.
  11. aws 使用 js 写的，用 ts 是最佳拍档（目前只学 tf，以后再说）
  12. CW 和 autoscale 中的，step scaling policy config 中的 step adjustment 的 metric_interval_upper_bound 和 lower bound 的作用？ 配合 CW，设置调整的上限和下限，设置多梯度的 scale 策略。eg. cloud watch 设置的监控值是 50，监控数值上限是 20，下限是 10，则新增一台机器。如果监控数值是 30，下限是 20，则新增 2 台。且上限值必须大于下限值。

### Docker image 打包多个标签/ALB 精讲

1. tag the docker built, one for the version tag, one for the latest tag

- docker tag <name> <image-name>:${BUILD_NUMBER}
- docker tag <name> <image-name>:latest

1. 通过 load balancer 访问多个服务器，如 jenkins，sonarqube，vault。
2. 将不同的路由 有 alb 进行分发，每个不需要单独生成证书，由 aws 负责生成

### Terraform Advance

- for_each：从 list, dict 中，一次取出；用 each 依次取出;

1. each.value
2. each.key

- lookup: 从 dict 中，根据 key 取出对应的 value

1. lookup(<待查找值>, <根据的 key>)

- file()

1. eg. public_key = file(”~/.ssh/key.pub”)

- template: templatefile(path, 赋值 vars) 可以用于创建 lambda，task_definition

1. template 例如生成 10 几个 cluster， ecs service


AWS Terraform


- Docker?
  - Docker is a set of PaaS products that deliver software in packages, which are isolated from one another and bundle their own software, libraries and configuration files.
- Why not a virtual machine?
  - Unlike virtual machines, containers do not have a high overhead and hence enable more efficient usage of the underlying system and resources.
- Container?
  - Containers offer a logical packaging mechanism in which applications can be abstracted from the environment in which they actually run. This decoupling allows container-based applications to be deployed easily and consistently, regardless of whether the target environment is a private data centre, the public cloud, or even a developer’s personal laptop.
  - benefits: predictable env, isolated from each other, run anywhere, more granular control over resources, improved efficiency and better utilization of your compute resources.
- Docker Image: The basis of a Docker container. Represents a full application.
- Docker Container: The standard unit in which the application service resides and executes.
- Docker Engine: Creates, ships and runs Docker containers deployable on a physical or virtual, host locally, in a data centre or cloud service provider.
- Repo (Docker Hub(Public) or Docker Trusted private): Cloud or server-based storage.

My understanding(In OO programming):

- Java class == image
- new instances == container
- GitHub == Docker Hub (repo)

Docker focuses more on the system level, which can be used to control the environment in the same version(dependencies).

- users can download an image from Docker Hub, and then initialize it to an instance that has the same environment as an image.
- this container can be reversed to an image(U can modify it) that will be passed to other users to share the same editing and environment. good version control and reproduced the results.

- sudo service docker start 启动 docker 服务器
- docker build -t <imageName> .
  - build an IMAGE from docker file
  - -t add tag name for this image
  - -f: 指定 dockerfile 路径
- docker image rm <imageName>
  - delete an IMAGE from the local image store
- docker run -p 80:5000 —name <containerName> <imageName>
  - run a CONTAINER based on an IMAGE in the front of the terminal
- docker run -d —rm -p 80:5000 —name <containerName> <imageName>
  - run a CONTAINER based on an IMAGE and run it in the background, and clean itself after closing this CONTAINER
  - -p: port mapping local: docker
  - -d: detach, run the container in the background and print container ID
  - —rm: rm, if u close this container
  - —name: container name
- docker stop <containerName>
  - 正常关机，可 resume
- docker kill <containerName>
  - 拔电源
- docker ps -a
  - list all the running containers including stopped containers
- docker restart <containerName> or <containerID>
  - restart a container

Dockerfile: text docs that can assemble an image, which can create an automated build

- FROM: initialize a new build stage with base IMAGE (from the local repo or public repo)
- ENV: key - value pair
- WORKDIR: working directory for any [RUN, CMD, ENTRYPOINT, COPY and ADD instructions]，指定登录终端后的落脚点
- COPY: COPY <src> <dest>
- ADD: 相当于 COPY + 自动处理 url 和 解压 tar 压缩包
- RUN: run commands in the current image (Linux) （其中，有<命令行命令> 和 <exec 格式> with String arr[’’]）
- EXPOSE: the container expose a specific port to listen
- ENTRYPOINT: 不会被 docker run 后面的命令覆盖（CMD 再给 entrypoint 传参）→ <ENTRYPOINT> <CMD>
- CMD：指定容器启动后要做的事情；在指定了 entrypoint 指令后，用 CMD 指定具体的参数；虽支持多个指令，但仅最后一个生效（会被 docker run 之后的参数 override，相当于 默认值）

PS: CMD 在 docker run 时运行， RUN 在 docker build 时运行

- docker exec -it <containerName> /bin/bash
  - 在 container 中操作已经部署的系统
  - -it: run the command in the container with bash, keep interactive
- docker container rm -f $(docker ps -aq)’
  - delete all the docker container
  - -q → quiet: only display container ID
  - -a → all
  - -f → force
- docker ps -q | xargs docker kill
  - rm all the containers
  - -q: 只显示容器编号
  - -a all
  - xargs: get params from pre pipeline processing
- docker images -qa | xargs docker rmi -f
  - list all the images with only 容器编号，并强制删除
- docker system prune
  - 清理不常用的数据 （-a, -f 有更深度清理，请移步文档）
- docker inspect demo
  - inspect the container
- docker cp your_file demo:/
  - copy a file into the container
- docker <command> your_docker_account_name/image_name:<tag>
  - tag 可以视为版本号，不填写默认为 latest

Docker-compose.yml：对 docker 容器集群的快速编排 - service: 一个个应用容器实例 eg. 订单微服务，库存微服务，mysql 容器 （一个应用的容器，可以包括若干运行相同的容器实例。每个服务都有自己的名字，使用镜像，依赖 XXX） - project: 有一组关联的容器组成的一个完整业务单元。1 project = 多个服务（容器应用实例） - 先写好 dockerfile，定义各个微服务并构建出对应的镜像 - 用 docker-compose 定义一个完整的 project，安排好整体应用中的各个容器，顺序，交互 - docker-compose up 一键部署

- docker-compose build: build all the docker files
- docker-compose up: run all the containers with dependencies
- docker-compose down: stop

[https://www.cnblogs.com/hsyw/p/13198448.html#:~:text=Compose 项目是 Docker 官方,可以启动多个容器！](https://www.cnblogs.com/hsyw/p/13198448.html#:~:text=Compose%E9%A1%B9%E7%9B%AE%E6%98%AFDocker%E5%AE%98%E6%96%B9,%E5%8F%AF%E4%BB%A5%E5%90%AF%E5%8A%A8%E5%A4%9A%E4%B8%AA%E5%AE%B9%E5%99%A8%EF%BC%81)

### DevOps Docker Volume

- docker build -f Dockerfile-check -t
- docker volume create sortlog-back
- docker volume inspect sortlog-back
- docker run -d -p 4000:4000 -v "$(pwd)/docker-output:/app/node_modules" vol_try
- docker run -d -p 4000:4000 -v sortlog-back:/app/node_modules vol_try
- dockerfile 中 volume


Docker, Docker compose, CLI

Docker/Docker Compose


### DevOps AWS IAM 1

![Untitled%2045.png](Untitled%2045.png)

![Untitled%2046.png](Untitled%2046.png)

- resources: the entities you create in AWS eg. S3 bucket or EC2
- Policy Statement
  1. Sid: name of this policy statement
  2. actions: perform actions on resources. eg. createBucket. type of access that is allowed or denied accesss
  3. implicit deny: 没声明的不行，deny 不行；同时给了 allow 和 deny，按照 deny 处理（aws 会先处理 deny 清单，pass 后处理 access 清单，都没有？deny）
  4. resource: limit the scope of this action. 对哪个 resource 执行的这个 action
  5. principal: 站在 resource 角度，决定谁可以使用本 resource。不太常见的原因是我们 attach policies to principles，这个 principle 要么是 role，要么是 user。definiation: the entity that is allowed or denied access. (就是我这个 policy 是针对谁的)
  6. condition: constraints that you can apply to your policy docs depending on context
- Policy 被赋予给一个用户时，该用户可以根据这个 policy 进行 UI web，CLI 和 SDK 的对资源进行操作
- Amazon Resource Name(ARN)：唯一指定 AWS 资源, 部分可省略，用::代替
  eg. arn:partition:service:region:account-id:resource-type:resource-id
- trust relationships: account1 trust account2, and account2 trust account2, so account can consume role from each other
- Least privileged model 够用就行原则

IAM policies:

1. Who should have access to do what?
2. AWS Evaluation: can this person call this action on this resource

when you define access policies. You specify which IAM **principals** are allowed to perform which **actions** on specific AWS **resources** and under which **conditions**

### DevOps AWS IAM 2

![1411662087834_.pic.jpg](1411662087834_.pic.jpg)

- Policy 分为 identity-based policy 和 resource-based policy
  1. 这两个是完全相互独立的，resource-based resource 相当于站在 resource 视角，看本 resource 可以被哪些资源所访问，且无法做到批量赋予，每个 resource 的 policy 都是根据情况单独赋予的（principal），跨 resource 间无法重复使用。
  2. identity-based policy 是站在 user, group 与 role 视角，可以被多次重复访问 和 批量赋予的
- roles: 非登录账号（不是 Group/User）的其他东西来使用 aws 的 service，将 AWS service 连接到 IAM 服务中。当我有一个 EC2 instance 时，会创建一个 role，使其可以去连接到 S3
- 每一个 policy 有多个 statements，但每个 statement 只有一个 policy
- resource-based-policy 主要去各个服务界面去设定，即服务之间的权限，让服务和对应的 resource 能够有权限进行通信
- role 和 resource-based policy 都可以让 resource 和 resource 之间进行通信 （前提是 role 中塞了相关的 resource-based policy）


All posts

EKS

AKS

K8s

CDN&DNS

Linux

Jenkins

AWS Terraform

Docker/Docker Compose

AWS IAM