apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.14.2
          ports:
            - containerPort: 80

kubectl apply -f deployment.yaml

apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
  name: <insert-your-cluster-name>
  region: ap-northeast-2
vpc:
  cidr: "<insert-your-cidr>"
  nat:
    gateway: HighlyAvailable
nodeGroups:
  - name: <insert-your-worker-name>
    instanceType: m5.large
    availabilityZones:
      - ap-northeast-2a
      - ap-northeast-2b
    labels:
      role: worker
    desiredCapacity: 2
    privateNetworking: true
    iam:
      withAddonPolicies:
        ebs: true
        efs: true
        autoScaler: true

eksctl create cluster -f cluster.yaml

kubectl config get-contexts

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-default
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
  type: gp2
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-default-a
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
  type: gp2
allowedTopologies:
  - matchLabelExpressions:
      - key: topology.ebs.csi.aws.com/zone
        values:
          - ap-northeast-2a
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-default-encrypted
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
  type: gp2
  encrypted: "true"
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-fast
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
  type: io1
  iopsPerGB: "10"

kubectl apply -f storage-classes.yaml
kubectl get storageclasses

kubectl apply -k "github.com/kubernetes-sigs/aws-ebs-csi-driver/deploy/kubernetes/overlays/stable/?ref=master"

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:AttachVolume",
                "ec2:CreateSnapshot",
                "ec2:CreateTags",
                "ec2:CreateVolume",
                "ec2:DeleteSnapshot",
                "ec2:DeleteTags",
                "ec2:DeleteVolume",
                "ec2:DescribeInstances",
                "ec2:DescribeSnapshots",
                "ec2:DescribeTags",
                "ec2:DescribeVolumes",
                "ec2:DetachVolume"
            ],
            "Resource": "*"
        }
    ]
}

kubectl get pods --namespace=kube-system

apiVersion: v1
kind: ServiceAccount
metadata:
  name: aws-alb-ingress-controller
  labels:
    app.kubernetes.io/name: aws-alb-ingress-controller
    helm.sh/chart: aws-alb-ingress-controller-0.1.11
    app.kubernetes.io/managed-by: Helm
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: aws-alb-ingress-controller
  labels:
    app.kubernetes.io/name: aws-alb-ingress-controller
    helm.sh/chart: aws-alb-ingress-controller-0.1.11
    app.kubernetes.io/managed-by: Helm
rules:
  - apiGroups:
      - ""
      - extensions
    resources:
      - configmaps
      - endpoints
      - events
      - ingresses
      - ingresses/status
      - services
    verbs:
      - create
      - get
      - list
      - update
      - watch
      - patch
  - apiGroups:
      - ""
      - extensions
    resources:
      - nodes
      - pods
      - secrets
      - services
      - namespaces
    verbs:
      - get
      - list
      - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: aws-alb-ingress-controller
  labels:
    app.kubernetes.io/name: aws-alb-ingress-controller
    helm.sh/chart: aws-alb-ingress-controller-0.1.11
    app.kubernetes.io/managed-by: Helm
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: aws-alb-ingress-controller
subjects:
  - kind: ServiceAccount
    name: aws-alb-ingress-controller
    namespace: default
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: aws-alb-ingress-controller
  labels:
    app.kubernetes.io/name: aws-alb-ingress-controller
    helm.sh/chart: aws-alb-ingress-controller-0.1.11
    app.kubernetes.io/managed-by: Helm
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: aws-alb-ingress-controller
  template:
    metadata:
      labels:
        app.kubernetes.io/name: aws-alb-ingress-controller
    spec:
      containers:
        - name: aws-alb-ingress-controller
          image: "docker.io/amazon/aws-alb-ingress-controller:v1.1.3"
          imagePullPolicy: IfNotPresent
          args:
            - --cluster-name=<your-cluster-name>
            - --ingress-class=alb
            - --aws-region=ap-northeast-2
            - --aws-vpc-id=<your-vpc-id>
          env:
          ports:
            - name: health
              containerPort: 10254
              protocol: TCP
          resources: {}
      serviceAccountName: aws-alb-ingress-controller
      terminationGracePeriodSeconds: 60

aws eks describe-cluster --name=<your-cluster-name>

kubectl apply -f aws-alb-ingress-controller.yaml
kubectl get all

kubectl get namespace

kubectl create namespace <insert-your-namespace-name>

kubectl delete namespace <insert-your-namespace-name>

kubectl api-resources --namespaced=true  // 네임스페이스에 속하는 리소스 조회
kubectl api-resources --namespaced=false // 네임스페이스에 속하지 않는 리소스 조회

kubectl get <NAME|SHORTNAMES> --namespace=<your-namespace>

kubectl get <NAME|SHORTNAMES>

kind: Service
apiVersion: v1
metadata:
  name: mariadb
  namespace: <your-namespace>
spec:
  type: ExternalName
  externalName: <database-endpoint>

kubectl apply -f external-name.yaml
kubectl get services --namespace=<your-namespace>

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mariadb-cli
  namespace: <your-namespace>
  labels:
    app: mariadb-cli
    component: client
spec:
  selector:
    matchLabels:
      app: mariadb-cli
      component: client
  replicas: 1
  template:
    metadata:
      labels:
        app: mariadb-cli
        component: client
    spec:
      serviceAccountName: default
      containers:
        - name: mariadb
          image: mariadb:10.3
          imagePullPolicy: "IfNotPresent"
          command: ["/bin/sh"]
          args:
            [
              "-c",
              "while true; do echo $(date +%Y-%m-%d' '%H:%M:%S); sleep 60; done",
            ]
          resources:
            requests:
              cpu: 50m
              memory: 64Mi
            limits:
              cpu: 100m
              memory: 64Mi

kubectl apply -f mariadb-cli.yaml
kubectl get pods --namespace=<your-namespace>

kubectl logs -f $(kubectl get pods -o jsonpath="{.items[0].metadata.name}" --namespace=<your-namespace> -l "app=mariadb-cli") --namespace=<your-namespace> --timestamps

kubectl exec -it <mariadb-cli-pod> --namespace=<your-namespace> bash
mysql -h <mariadb-external-name> -u admin -p
Enter Password: <mariadb-password>

CREATE USER 'maxscale'@'%' IDENTIFIED BY '<insert-your-maxscale-password>';
GRANT SELECT ON mysql.user TO 'maxscale'@'%';
GRANT SELECT ON mysql.db TO 'maxscale'@'%';
GRANT SELECT ON mysql.tables_priv TO 'maxscale'@'%';
GRANT SELECT ON mysql.roles_mapping TO 'maxscale'@'%';
GRANT SHOW DATABASES ON *.* TO 'maxscale'@'%';

SELECT Host, User FROM mysql.user;

[master]
type=server
address=mariadb
port=3306
protocol=MariaDBBackend

[slave1]
type=server
address=mariadb
port=3306
protocol=MariaDBBackend

[slave2]
type=server
address=mariadb
port=3306
protocol=MariaDBBackend

# Monitor for the servers
# This will keep MaxScale aware of the state of the servers.
# MySQL Monitor documentation:
# https://github.com/mariadb-corporation/MaxScale/blob/2.3/Documentation/Monitors/MariaDB-Monitor.md

[MariaDB-Monitor]
type=monitor
module=mariadbmon
servers=master
user=maxscale
passwd=<your-maxscale-password>
auto_failover=true
auto_rejoin=true
enforce_read_only_slaves=1

# Service definitions
# Service Definition for a read-only service and a read/write splitting service.

# ReadConnRoute documentation:
# https://github.com/mariadb-corporation/MaxScale/blob/2.3/Documentation/Routers/ReadConnRoute.md

[Read-Only-Service]
type=service
router=readconnroute
servers=master
user=maxscale
passwd=<your-maxscale-password>
router_options=slave

# ReadWriteSplit documentation:
# https://github.com/mariadb-corporation/MaxScale/blob/2.3/Documentation/Routers/ReadWriteSplit.md

[Read-Write-Service]
type=service
router=readwritesplit
servers=master
user=maxscale
passwd=<your-maxscale-password>
master_failure_mode=fail_on_write

# Listener definitions for the services
# Listeners represent the ports the services will listen on.

[Read-Only-Listener]
type=listener
service=Read-Only-Service
protocol=MySQLClient
port=4008
address=0.0.0.0

[Read-Write-Listener]
type=listener
service=Read-Write-Service
protocol=MySQLClient
port=4006
address=0.0.0.0

kubectl create secret generic maxscale-config --from-file=my-maxscale.cnf=<repository-absolute-path>/my-maxscale.cnf --namespace=<your-namespace>
kubectl get secrets --namespace=<your-namespace>

apiVersion: v1
kind: Service
metadata:
  name: maxscale
  namespace: <your-namespace>
  labels:
    app: maxscale
spec:
  ports:
    - port: 4006
      targetPort: 4006
      protocol: TCP
  selector:
    app: maxscale
  type: ClusterIP
---
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: maxscale
  namespace: <your-namespace>
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: maxscale
    spec:
      initContainers:
        - name: init-myservice
          image: mariadb/maxscale:2.3
          volumeMounts:
            - name: conf-d
              mountPath: /tmp/maxscale.cnf.d
            - name: secret-conf-d
              mountPath: /tmp/source.maxscale.cnf.d
          command:
            - "sh"
            - "-c"
            - "cat /tmp/source.maxscale.cnf.d/my-maxscale.cnf >> /tmp/maxscale.cnf.d/my-maxscale.cnf"
      containers:
        - name: maxscale
          image: mariadb/maxscale:2.3
          imagePullPolicy: IfNotPresent
          resources:
            requests:
              cpu: 50m
              memory: 200Mi
            limits:
              cpu: 300m
              memory: 300Mi
          ports:
            - containerPort: 4006
              name: readwrite-port
            - containerPort: 4008
              name: readonly-port
          volumeMounts:
            - name: conf-d
              mountPath: "/etc/maxscale.cnf.d"
              readOnly: true
      volumes:
        - name: secret-conf-d
          secret:
            secretName: maxscale-config
            items:
              - key: my-maxscale.cnf
                path: my-maxscale.cnf
        - name: conf-d
          emptyDir: {}

kubectl apply -f maxscale.yaml
kubectl get services --namespace=<your-namespace>

kubectl port-forward service/maxscale 4006:4006 --namespace=<your-namespace>

echo -n '<username>:<password>' | base64

{
  "auths": {
    "https://index.docker.io/v1/": {
      "auth": "<base64-encoded-string>"
    }
  }
}

cat config.json | base64

apiVersion: v1
kind: Secret
metadata:
  name: dockerhub
  namespace: <your-namespace>
type: kubernetes.io/dockerconfigjson
data:
  .dockerconfigjson: <base64-encoded-string>

kubectl apply -f dockerhub.yaml
kubectl get secrets --namespace=<your-namespace>
kubectl describe secrets/dockerhub --namespace=<your-namespace>

...
spec:
  imagePullSecrets:
    - name: dockerhub