Comando Kubernetes Create: Crie e Gerencie Recursos

Introdução

O comando kubectl create é uma ferramenta essencial para criar recursos Kubernetes. Ele utiliza arquivos YAML ou JSON para definir recursos como namespaces, deployments, services, secrets e ConfigMaps. Neste laboratório, você aprenderá como criar esses recursos passo a passo e entender seus papéis no Kubernetes.

Ao final deste laboratório, você:

Iniciará e verificará um cluster Minikube.
Criará e verificará vários recursos Kubernetes usando kubectl create.

Iniciar o Minikube e Verificar o Cluster

Antes de trabalhar com Kubernetes, você precisa de um cluster em execução. O Minikube fornece um cluster Kubernetes local leve.

Navegue para o diretório do seu projeto:

Abra seu terminal e navegue até o diretório de trabalho padrão:
```
cd /home/labex/project
```
Iniciar o Minikube:

Inicie o Minikube para inicializar o cluster:
```
minikube start
```
- O Minikube cria um cluster Kubernetes de nó único. Esta etapa pode levar alguns minutos.
Verificar o status do Minikube:

Verifique se o Minikube foi iniciado com sucesso:
```
minikube status
```
Procure por componentes como apiserver e kubelet listados como Running.
Confirmar a configuração do Kubernetes:

Certifique-se de que o kubectl está conectado ao cluster Minikube:
```
kubectl cluster-info
```
Isso exibe detalhes sobre o servidor da API e outros componentes.

Se o Minikube falhar ao iniciar. Use minikube delete para redefinir e tentar novamente.

Explorar o Comando kubectl create

O comando kubectl create fornece múltiplos subcomandos para criar recursos Kubernetes. Ele auxilia no gerenciamento da criação de recursos como namespaces, deployments, services, secrets e ConfigMaps.

Execute o seguinte comando para visualizar os subcomandos kubectl create disponíveis:

kubectl create -h

Você verá a seguinte saída:

Create a resource from a file or from stdin.

JSON and YAML formats are accepted.

Examples:
  ## Create a pod using the data in pod.json
  kubectl create -f ./pod.json

  ## Create a pod based on the JSON passed into stdin
  cat pod.json | kubectl create -f -

  ## Edit the data in registry.yaml in JSON then create the resource using the edited data
  kubectl create -f registry.yaml --edit -o json

Available Commands:
  clusterrole           Create a cluster role
  clusterrolebinding    Create a cluster role binding for a particular cluster role
  configmap             Create a config map from a local file, directory or literal value
  cronjob               Create a cron job with the specified name
  deployment            Create a deployment with the specified name
  ingress               Create an ingress with the specified name
  job                   Create a job with the specified name
  namespace             Create a namespace with the specified name
  poddisruptionbudget   Create a pod disruption budget with the specified name
  priorityclass         Create a priority class with the specified name
  quota                 Create a quota with the specified name
  role                  Create a role with single rule
  rolebinding           Create a role binding for a particular role or cluster role
  secret                Create a secret using specified subcommand
  service               Create a service using a specified subcommand
  serviceaccount        Create a service account with the specified name
  token                 Request a service account token

Revise os subcomandos disponíveis e suas descrições para entender como o kubectl create pode ser usado.

Criar um Namespace

Namespaces permitem que você organize e isole recursos no Kubernetes.

Criar um arquivo de definição de namespace:

Abra um novo arquivo chamado namespace.yaml:
```
nano namespace.yaml
```
Definir o namespace:

Adicione o seguinte conteúdo:
```
apiVersion: v1
kind: Namespace
metadata:
  name: mynamespace
```
Salve o arquivo pressionando Ctrl+X, depois Y e Enter.
Aplicar o namespace:

Crie o namespace:
```
kubectl create -f namespace.yaml
```
Verificar o namespace:

Verifique a lista de namespaces:
```
kubectl get namespaces
```
Confirme que mynamespace aparece na saída.

Criar um Deployment

Deployments gerenciam e mantêm o estado desejado dos pods.

Criar um arquivo de definição de deployment:

Abra um arquivo chamado deployment.yaml:
```
nano deployment.yaml
```

Definir o deployment:

Adicione o seguinte conteúdo para implantar três réplicas de um container Nginx:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mydeployment
  namespace: mynamespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: nginx-container
          image: nginx

Salve o arquivo.

Aplicar o deployment:

Crie o deployment:
```
kubectl create -f deployment.yaml
```
Verificar o deployment:

Verifique o deployment e seus pods:
```
kubectl get deployments -n mynamespace
kubectl get pods -n mynamespace
```
Certifique-se de que três pods estejam em execução.

Criar um Service

Um service fornece acesso de rede estável a um conjunto de pods.

Criar um arquivo de definição de service:

Abra um arquivo chamado service.yaml:
```
nano service.yaml
```

Definir o service:

Adicione o seguinte conteúdo:

apiVersion: v1
kind: Service
metadata:
  name: myservice
  namespace: mynamespace
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Salve o arquivo.

Aplicar o service:

Crie o service:
```
kubectl create -f service.yaml
```
Verificar o service:

Verifique a lista de services:
```
kubectl get services -n mynamespace
```
Confirme que myservice está listado.

Criar um Secret

Secrets armazenam com segurança informações sensíveis, como senhas ou chaves de API.

Criar um arquivo de definição de secret:

Abra um arquivo chamado secret.yaml:
```
nano secret.yaml
```

Definir o secret:

Adicione o seguinte conteúdo com valores codificados em Base64:

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
  namespace: mynamespace
type: Opaque
data:
  username: dXNlcm5hbWU= ## Base64 for "username"
  password: cGFzc3dvcmQ= ## Base64 for "password"

Salve o arquivo.

Aplicar o secret:

Crie o secret:
```
kubectl create -f secret.yaml
```
Verificar o secret:

Verifique a lista de secrets:
```
kubectl get secrets -n mynamespace
```
Confirme que mysecret aparece na saída.

Criar um ConfigMap

ConfigMaps armazenam dados de configuração em pares chave-valor.

Criar um arquivo de definição de ConfigMap:

Abra um arquivo chamado configmap.yaml:
```
nano configmap.yaml
```

Definir o ConfigMap:

Adicione o seguinte conteúdo:

apiVersion: v1
kind: ConfigMap
metadata:
  name: myconfigmap
  namespace: mynamespace
data:
  database.host: "example.com"
  database.port: "5432"

Salve o arquivo.

Aplicar o ConfigMap:

Crie o ConfigMap:
```
kubectl create -f configmap.yaml
```
Verificar o ConfigMap:

Verifique a lista de ConfigMaps:
```
kubectl get configmaps -n mynamespace
```
Confirme que myconfigmap aparece na saída.

Resumo

Neste laboratório, você aprendeu a:

Iniciar e verificar um cluster Minikube.
Criar recursos Kubernetes como namespaces, deployments, services, secrets e ConfigMaps.
Verificar o status desses recursos.

Ao dominar essas etapas, você será capaz de gerenciar e implantar aplicações de forma eficaz no Kubernetes. Pratique essas etapas para fortalecer sua compreensão!