One place for hosting & domains

      Rápida

      Introdução ao Kubernetes: Um Guia de Referência Rápida do kubectl


      Introdução

      O Kubectl é uma ferramenta de linha de comando projetada para gerenciar objetos e clusters Kubernetes. Ele fornece uma interface de linha de comando para executar operações comuns, como criar e escalar Deployments, alternar contextos e acessar um shell em um container em execução.

      Como Usar Este Guia:

      • Este guia está no formato de referência rápida com trechos de linha de comando independentes.
      • Ele não é uma lista exaustiva de comandos kubectl, mas contém muitas operações e casos de uso comuns. Para uma referência mais completa, consulte a Documentação de referência do Kubectl
      • Vá para qualquer seção que seja relevante para a tarefa que você está tentando concluir.

      Pré-requisitos

      • Para usar o kubectl, você precisará de um cluster Kubernetes disponível para você. Para aprender a criar um cluster Kubernetes do zero, você pode consultar Como Criar um Cluster Kubernetes 1.11 Usando Kubeadm no Ubuntu 18.04. Alternativamente, você pode provisionar um cluster Kubernetes gerenciado em minutos usando o DigitalOcean Kubernetes. Para começar a criar um cluster Kubernetes gerenciado na DigitalOcean, consulte How to Create Kubernetes Clusters Using the Control Panel.
      • Você também precisará de uma máquina remota na qual instalará e executará o kubectl. O kubectl pode ser executado em diversos sistemas operacionais.

      Deployment de Exemplo

      Para demonstrar algumas das operações e comandos nesta referência rápida, usaremos um exemplo de Deployment que executa duas réplicas do Nginx:

      nginx-deployment.yaml

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

      Copie e cole esse manifesto em um arquivo chamado nginx-deployment.yaml.

      Instalando o kubectl

      Nota: Esses comandos foram testados somente em uma máquina Ubuntu 18.04. Para aprender como instalar o kubectl em outros sistemas operacionais, consulte Install and Set Up kubectl da documentação do Kubernetes.

      Primeiro, atualize o índice local de pacotes e instale as dependências necessárias:

      • sudo apt-get update && sudo apt-get install -y apt-transport-https

      Em seguida, adicione a chave GPG do Google Cloud ao APT e disponibilize o pacote kubectl no seu sistema:

      • curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

      • echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list

      • sudo apt-get update

      Por fim, instale o kubectl:

      • sudo apt-get install -y kubectl

      Teste se a instalação foi bem-sucedida usando version:

      Configurando o Autocompletar no Shell

      Nota: Esses comandos foram testados somente em uma máquina Ubuntu 18.04. Para saber como configurar o Autocompletar em outros sistemas operacionais, consulte Install and Set Up kubectl da documentação do Kubernetes.

      O kubectl inclui um script de autocompletar no shell que você pode disponibilizar para o software de autocompletar do shell existente no sistema.

      Instalando o Autocompletar do kubectl

      Primeiro, verifique se você tem o bash-completion instalado:

      Você deve ver alguma saída do script.

      Em seguida, faça um source no script de autocompletar do kubectl em seu arquivo ~/.bashrc:

      • echo 'source <(kubectl completion bash)' >>~/.bashrc

      • . ~/.bashrc

      Alternativamente, você pode adicionar o script de autocompletar ao diretório /etc/bash_completion.d:

      • kubectl completion bash >/etc/bash_completion.d/kubectl

      Uso

      Para usar o recurso de autocompletar, pressione a tecla TAB para exibir os comandos kubectl disponíveis:

      Output
      annotate       apply          autoscale      completion     cordon         delete         drain          explain        kustomize      options        port-forward   rollout        set            uncordon
api-resources  attach         certificate    config         cp             describe
. . .

      Você também pode exibir os comandos disponíveis após digitar parcialmente um comando:

      Output
      delete    describe  diff      drain

      Conectando, Configurando e Usando Contextos

      Conectando

      Para testar se o kubectl pode se autenticar e acessar seu cluster Kubernetes, use cluster-info:

      Se o kubectl puder se autenticar com sucesso no seu cluster, você deverá ver a seguinte saída:

      Output
      Kubernetes master is running at https://kubernetes_master_endpoint
CoreDNS is running at https://coredns_endpoint

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

      O kubectl é configurado usando os arquivos de configuração kubeconfig. Por padrão, o kubectl procurará um arquivo chamado config no diretório $HOME/.kube. Para mudar isso, você pode definir a variável de ambiente $KUBECONFIG apontando para um arquivo kubeconfig personalizado ou passar o arquivo personalizado em tempo de execução usando a flag --kubeconfig:

      • kubectl cluster-info --kubeconfig=caminho_para_seu_arquivo_kubeconfig

      Nota: Se você estiver usando um cluster Kubernetes gerenciado, seu provedor de nuvem deverá ter disponibilizado seu arquivo kubeconfig.

      Se você não quiser usar a flag --kubeconfig com todos os comandos, e não existe o arquivo ~/.kube/config, crie um diretório chamado ~/.kube no seu diretório home, se ele ainda não existir, e copie o arquivo kubeconfig, renomeando-o para config:

      • mkdir ~/.kube

      • cp seu_arquivo_kubeconfig ~/.kube/config

      Agora, execute cluster-info novamente para testar sua conexão.

      Modificando Sua Configuração do kubectl

      Você também pode modificar sua configuração usando o conjunto de comandos kubectl config.

      Para visualizar sua configuração do kubectl, use o subcomando view:

      Output
      apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: DATA+OMITTED
. . .

      Modificando Clusters

      Para buscar uma lista de clusters definidos no seu kubeconfig, use get-clusters:

      • kubectl config get-clusters

      Output
      NAME
do-nyc1-sammy

      Para adicionar um cluster à sua configuração, use o subcomando set-cluster:

      • kubectl config set-cluster novo_cluster --server=endereço_do_servidor --certificate-authority=caminho_para_a_autoridade_de_certificação

      Para excluir um cluster da sua configuração, use delete-cluster:

      Nota: Isso exclui apenas o cluster da sua configuração e não exclui o cluster Kubernetes real.

      • kubectl config delete-cluster

      Modificando Usuários

      Você pode executar operações similares para usuários usando set-credentials:

      • kubectl config set-credentials username --client-certificate=/caminho/para/arquivo/certificado --client-key=/caminho/para/arquivo/chave

      Para excluir um usuário da sua configuração, você pode executar unset:

      • kubectl config unset users.username

      Contextos

      Um context ou contexto no Kubernetes é um objeto que contém um conjunto de parâmetros de acesso para o seu cluster. Ele consiste em uma tripla de cluster, namespace e user. Os contextos permitem alternar rapidamente entre diferentes conjuntos de configurações de cluster.

      Para ver seu contexto atual, você pode usar current-context:

      • kubectl config current-context

      Output
      do-nyc1-sammy

      Para ver uma lista de todos os contextos configurados, execute get-contexts:

      • kubectl config get-contexts

      Output
      CURRENT   NAME            CLUSTER         AUTHINFO              NAMESPACE
*         do-nyc1-sammy   do-nyc1-sammy   do-nyc1-sammy-admin

      Para definir um contexto, use set-context:

      • kubectl config set-context nome_do_contexto --cluster=nome_do_cluster --user=user_name --namespace=namespace

      Você pode alternar entre contextos com use-context:

      • kubectl config use-context nome_do_contexto

      Output
      Switched to context "do-nyc1-sammy"

      E você pode excluir um contexto com delete-context:

      • kubectl config delete-context nome_do_contexto

      Usando Namespaces

      Um Namespace no Kubernetes é uma abstração que lhe permite subdividir seu cluster em vários clusters virtuais. Usando Namespaces, você pode dividir os recursos do cluster entre várias equipes e objetos de escopo de maneira apropriada. Por exemplo, você pode ter um Namespace prod para cargas de trabalho de produção e um Namespace dev para cargas de trabalho de desenvolvimento e teste.

      Para buscar e imprimir uma lista de todos os Namespaces no cluster, use get namespace:

      Output
      NAME              STATUS   AGE
default           Active   2d21h
kube-node-lease   Active   2d21h
kube-public       Active   2d21h
kube-system       Active   2d21h

      Para definir um Namespace para o seu contexto atual, use set-context --current:

      • kubectl config set-context --current --namespace=nome_do_namespace

      Para criar um Namespace, use create namespace:

      • kubectl create namespace namespace_name

      Output
      namespace/sammy created

      De maneira similar, para excluir um Namespace, use delete namespace:

      Atenção: A exclusão de um Namespace excluirá tudo no Namespace, incluindo a execução de Deployments, Pods e outras cargas de trabalho. Execute este comando apenas se tiver certeza de que deseja eliminar o que está sendo executado no Namespace ou se estiver excluindo um Namespace vazio.

      • kubectl delete namespace nome_do_namespace

      Para buscar todos os Pods em um determinado Namespace ou para realizar outras operações nos recursos de um determinado Namespace, certifique-se de incluir a flag --namespace:

      • kubectl get pods --namespace=nome_do_namespace

      Gerenciando Recursos do Kubernetes

      Sintaxe Geral

      A sintaxe geral para a maioria dos comandos de gerenciamento do kubectl é:

      • kubectl command type name flags

      Onde

      • command é uma operação que você gostaria de executar, como create
      • type é o tipo de recurso do Kubernetes, como deployment
      • name é o nome do recurso, como app_frontend
      • flags são todas as flags opcionais que você gostaria de incluir

      Por exemplo, o comando a seguir recupera informações sobre um Deployment chamado app_frontend:

      • kubectl get deployment app_frontend

      Gestão Declarativa e kubectl apply

      A abordagem recomendada para gerenciar cargas de trabalho no Kubernetes é confiar no design declarativo do cluster o máximo possível. Isso significa que, em vez de executar uma série de comandos para criar, atualizar, excluir e reiniciar a execução de Pods, você deve definir as cargas de trabalho, serviços e sistemas que deseja executar nos arquivos de manifesto YAML e fornecer esses arquivos ao Kubernetes, que cuidará do resto.

      Na prática, isso significa usar o comando kubectl apply, que aplica uma configuração específica a um determinado recurso. Se o recurso de destino não existir, o Kubernetes criará o recurso. Se o recurso já existir, o Kubernetes salvará a revisão atual e atualizará o recurso de acordo com a nova configuração. Essa abordagem declarativa existe em contraste com a abordagem imperativa de executar o conjunto de comandos kubectl create, kubectl edit e kubectl scale para gerenciar recursos. Para saber mais sobre as diferentes maneiras de gerenciar os recursos do Kubernetes, consulte Gerenciamento de objetos do Kubernetes na documentação do Kubernetes.

      Lançando um Deployment

      Por exemplo, para fazer o deploy de exemplo do Nginx em seu cluster, use apply e forneça o caminho para o arquivo de manifesto nginx-deployment.yaml:

      • kubectl apply -f nginx-deployment.yaml

      Output
      deployment.apps/nginx-deployment created

      A flag -f é usada para especificar um nome de arquivo ou URL contendo uma configuração válida. Se você deseja aplicar todos os manifestos de um diretório, você pode usar a flag -k:

      • kubectl apply -k diretório_do_manifesto

      Você pode acompanhar o status do deployment usando rollout status:

      • kubectl rollout status deployment/nginx-deployment

      Output
      Waiting for deployment "nginx-deployment" rollout to finish: 1 of 2 updated replicas are available...
deployment "nginx-deployment" successfully rolled out

      Um alternativa ao rollout status é o comando kubectl get, juntamente com a flag -w (watch):

      • kubectl get deployment -w

      Output
      NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   0/2     2            0           3s
nginx-deployment   1/2     2            1           3s
nginx-deployment   2/2     2            2           3s

      Usando rollout pause e rollout resume, você pode pausar e retomar o lançamento ou rollout de um Deployment:

      • kubectl rollout pause deployment/nginx-deployment

      Output
      deployment.extensions/nginx-deployment paused

      • kubectl rollout resume deployment/nginx-deployment

      Output
      deployment.extensions/nginx-deployment resumed

      Modificando um Deployment em Execução

      Se você quiser modificar um Deployment em execução, poderá fazer alterações no seu arquivo de manifesto e, em seguida, executar o kubectl apply novamente para aplicar a atualização. Por exemplo, vamos modificar o arquivo nginx-deployment.yaml para alterar o número de réplicas de 2 para 3:

      nginx-deployment.yaml

      . . .
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
. . .

      O comando kubectl diff permite que você veja diferenças entre os recursos em execução no momento e as alterações propostas no arquivo de configuração fornecido:

      • kubectl diff -f nginx-deployment.yaml

      Agora permita que o Kubernetes execute a atualização usando apply:

      • kubectl apply -f nginx-deployment.yaml

      A execução de outro get deployment deve confirmar a adição de uma terceira réplica.

      Se você executar apply novamente sem modificar o arquivo de manifesto, o Kubernetes detectará que nenhuma alteração foi feita e não executará nenhuma ação.

      Usando o rollout history, você pode ver uma lista das revisões anteriores do Deployment:

      • kubectl rollout history deployment/nginx-deployment

      Output
      deployment.extensions/nginx-deployment
REVISION  CHANGE-CAUSE
1         <none>

      Com rollout undo, você pode reverter um Deployment para qualquer uma das revisões anteriores:

      • kubectl rollout undo deployment/nginx-deployment --to-revision=1

      Excluindo um Deployment

      Para excluir um deployment em execução, use kubectl delete:

      • kubectl delete -f nginx-deployment.yaml

      Output
      deployment.apps "nginx-deployment" deleted

      Gerenciamento Imperativo

      Você também pode usar um conjunto de comandos imperativos para manipular e gerenciar diretamente os recursos do Kubernetes.

      Criando um Deployment

      Use create para criar um objeto a partir de um arquivo, URL ou STDIN. Observe que, ao contrário de apply, se um objeto com o mesmo nome já existir, a operação irá falhar. A flag --dry-run lhe permite visualizar o resultado da operação sem realmente executá-la:

      • kubectl create -f nginx-deployment.yaml --dry-run

      Output
      deployment.apps/nginx-deployment created (dry-run)

      Agora podemos criar o objeto:

      • kubectl create -f nginx-deployment.yaml

      Output
      deployment.apps/nginx-deployment created

      Modificando um Deployment em Execução

      Use scale para escalar o número de réplicas para o Deployment de 2 para 4:

      • kubectl scale --replicas=4 deployment/nginx-deployment

      Output
      deployment.extensions/nginx-deployment scaled

      Você pode editar qualquer objeto localmente usando o kubectl edit. Isso abrirá o manifesto do objeto no seu editor padrão:

      • kubectl edit deployment/nginx-deployment

      Você deve ver o seguinte arquivo de manifesto em seu editor:

      nginx-deployment

      # Please edit the object below. Lines beginning with a "https://www.digitalocean.com/#" will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: extensions/v1beta1
kind: Deployment
. . . 
spec:
  progressDeadlineSeconds: 600
  replicas: 4
  revisionHistoryLimit: 10
  selector:
    matchLabels:
. . .

      Altere o valor das replicas de 4 para 2, depois salve e feche o arquivo.

      Agora execute um get para inspecionar as alterações:

      • kubectl get deployment/nginx-deployment

      Output
      NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   2/2     2            2           6m40s

      Escalamos o Deployment com êxito de volta para duas réplicas on-the-fly (ou seja, durante a operação). Você pode atualizar a maioria dos campos de um objeto do Kubernetes de maneira semelhante.

      Outro comando útil para modificar objetos localmente é o kubectl patch. Usando o patch, você pode atualizar os campos de um objeto on-the-fly, sem precisar abrir o seu editor. O patch também permite atualizações mais complexas com várias estratégias de mesclagem e correção. Para saber mais sobre isso, consulte Update API Objects in Place Using kubectl patch.

      O comando a seguir irá corrigir o objeto nginx-deployment para atualizar o campo replicas de 2 para 4; deploy é uma abreviação para o objeto deployment.

      • kubectl patch deploy nginx-deployment -p '{"spec": {"replicas": 4}}'

      Output
      deployment.extensions/nginx-deployment patched

      Agora podemos inspecionar as alterações:

      • kubectl get deployment/nginx-deployment

      Output
      NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   4/4     4            4           18m

      Você também pode criar um Deployment imperativamente usando o comando run. O run criará um Deployment usando uma imagem fornecida como parâmetro:

      • kubectl run nginx-deployment --image=nginx --port=80 --replicas=2

      O comando expose permite expor rapidamente um Deployment em execução como um Serviço Kubernetes, permitindo conexões de fora do seu cluster Kubernetes:

      • kubectl expose deploy nginx-deployment --type=LoadBalancer --port=80 --name=nginx-svc

      Output
      service/nginx-svc exposed

      Aqui, expusemos o Deployment nginx-deployment como um serviço LoadBalancer, abrindo a porta 80 para o tráfego externo e direcionando-a para a porta 80 do container. Nomeamos o serviço como nginx-svc. Usando o tipo de Serviço LoadBalancer, um balanceador de carga em nuvem é automaticamente provisionado e configurado pelo Kubernetes. Para obter o endereço IP externo do Serviço, use get:

      • kubectl get svc nginx-svc

      Output
      NAME        TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)        AGE
nginx-svc   LoadBalancer   10.245.26.242   203.0.113.0   80:30153/TCP   22m

      Você pode acessar os containers Nginx em execução indo até o EXTERNAL-IP no seu navegador web.

      Inspecionando Cargas de Trabalho e Debugando

      Existem vários comandos que você pode usar para obter mais informações sobre cargas de trabalho em execução no seu cluster.

      Inspecionando Recursos no Kubernetes

      O kubectl get busca um determinado recurso do Kubernetes e exibe algumas informações básicas associadas a ele:

      • kubectl get deployment -o wide

      Output
      NAME               READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES   SELECTOR
nginx-deployment   4/4     4            4           29m   nginx        nginx    app=nginx

      Como não fornecemos um nome de Deployment ou um Namespace, o kubectl busca todos os Deployments no Namespace atual. A flag -o fornece informações adicionais como CONTAINERS e IMAGES.

      Além do get, você pode usar o describe para buscar uma descrição detalhada do recurso e dos recursos associados:

      • kubectl describe deploy nginx-deployment

      Output
      Name:                   nginx-deployment
Namespace:              default
CreationTimestamp:      Wed, 11 Sep 2019 12:53:42 -0400
Labels:                 run=nginx-deployment
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               run=nginx-deployment
. . .

      O conjunto de informações apresentadas variará dependendo do tipo de recurso. Você também pode usar este comando sem especificar um nome de recurso; nesse caso, as informações serão fornecidas para todos os recursos desse tipo no Namespace atual.

      O explain permite que você puxe rapidamente campos configuráveis para um determinado tipo de recurso:

      • kubectl explain deployment.spec

      Ao acrescentar campos adicionais, você pode mergulhar mais fundo na hierarquia de campos:

      • kubectl explain deployment.spec.template.spec

      Obtendo Acesso ao Shell de um Container

      Para obter acesso ao shell de um container em execução, use exec. Primeiro, encontre o Pod que contém o container em execução ao qual você deseja acessar:

      Output
      nginx-deployment-8859878f8-7gfw9   1/1     Running   0          109m
nginx-deployment-8859878f8-z7f9q   1/1     Running   0          109m

      Vamos fazer um exec para o primeiro Pod. Como este Pod possui apenas um container, não precisamos usar a flag -c para especificar em qual container gostaríamos de fazer o exec.

      • kubectl exec -i -t nginx-deployment-8859878f8-7gfw9 -- /bin/bash

      Output
      root@nginx-deployment-8859878f8-7gfw9:/#

      Agora você tem acesso ao shell do container Nginx. A flag -i passa o STDIN para o container e -t fornece um TTY interativo. O traço duplo -- atua como um separador para o comando kubectl e o comando que você deseja executar dentro do container. Neste caso, estamos executando o /bin/bash.

      Para executar comandos dentro do container sem abrir um shell completo, omita as flags -i e -t e substitua o comando que você deseja executar em vez de /bin/bash:

      • kubectl exec nginx-deployment-8859878f8-7gfw9 ls

      Output
      bin
boot
dev
etc
home
lib
lib64
media
. . .

      Buscando Logs

      Outro comando útil é o logs, que imprime logs de Pods e containers, incluindo containers finalizados.

      Para transmitir logs para a saída do seu terminal, você pode usar a flag -f:

      • kubectl logs -f nginx-deployment-8859878f8-7gfw9

      Output
      10.244.2.1 - - [12/Sep/2019:17:21:33 +0000] "GET / HTTP/1.1" 200 612 "-" "203.0.113.0" "-"
2019/09/16 17:21:34 [error] 6#6: *1 open() "/usr/share/nginx/html/favicon.ico" failed (2: No such file or directory), client: 10.244.2.1, server: localhost, request: "GET /favicon.ico HTTP/1.1", host: "203.0.113.0", referrer: "http://203.0.113.0"
. . .

      Este comando continuará sendo executado no seu terminal até ser interrompido com um CTRL+C. Você pode omitir a flag -f se quiser imprimir a saída do log e sair imediatamente.

      Você também pode usar a flag -p para buscar logs de um container terminado. Quando esta opção é usada dentro de um Pod que tinha uma instância anterior do container em execução, logs imprimirá a saída do container finalizado:

      • kubectl logs -p nginx-deployment-8859878f8-7gfw9

      A flag -c lhe permite especificar o container do qual você deseja buscar logs, se o Pod tiver vários containers. Você pode usar a flag --all-containers=true para buscar logs de todos os containers no Pod.

      Redirecionamento de Porta e Proxying

      Para obter acesso de rede a um Pod, você pode usar o port-forward:

      • sudo kubectl port-forward pod/nginx-deployment-8859878f8-7gfw9 80:80

      Output
      Forwarding from 127.0.0.1:80 -> 80
Forwarding from [::1]:80 -> 80

      Neste caso, usamos sudo porque a porta 80 local é uma porta protegida. Para a maioria das outras portas, você pode omitir o sudo e executar o comando kubectl como seu usuário do sistema.

      Aqui redirecionamos a porta 80 local (que antecede os dois pontos) para a porta 80 do container do Pod (após os dois pontos).

      Você também pode usar deploy/nginx-deployment como tipo e nome do recurso para o qual redirecionar. Se você fizer isso, a porta local será redirecionada para o Pod selecionado pelo Deployment.

      O comando proxy pode ser usado para acessar o servidor de API do Kubernetes localmente:

      • kubectl proxy --port=8080

      Output
      Starting to serve on 127.0.0.1:8080

      Em outro shell, use curl para explorar a API:

      • curl http://localhost:8080/api/

      Output
      {
  "kind": "APIVersions",
  "versions": [
    "v1"
  ],
  "serverAddressByClientCIDRs": [
    {
      "clientCIDR": "0.0.0.0/0",
      "serverAddress": "203.0.113.0:443"
    }
  ]

      Feche o proxy pressionando CTRL-C.

      Conclusão

      Este guia aborda alguns dos comandos mais comuns do kubectl que você pode usar ao gerenciar um cluster Kubernetes e as cargas de trabalho deployadas nele.

      Você pode aprender mais sobre o kubectl consultando a documentação de referência oficial do Kubernetes.

      Existem muitos outros comandos e variações que você pode achar úteis como parte do seu trabalho com o kubectl. Para saber mais sobre todas as suas opções disponíveis, você pode executar:



      Source link

      Cómo configurar la plataforma de IDE en la nube code-server en Ubuntu 18.04 [guía rápida]


      Introducción

      code-server es Microsoft Visual Studio Code en ejecución en un servidor remoto, y usted puede acceder a él de forma directa desde su navegador. Esto significa que puede usar varios dispositivos con diferentes sistemas operativos y tener siempre a mano un entorno de desarrollo uniforme.

      A través de este tutorial, configurará la plataforma de IDE en la nube code-server en su equipo con Ubuntu 18.04 y la expondrá en su dominio, protegida con Let´s Encrypt. Para hallar una versión más detallada de este tutorial, consulte Cómo configurar la plataforma de IDE en la nube code-server en Ubuntu 18.04.

      Requisitos previos

      • Un servidor con Ubuntu 18.04 con al menos 2 GB de RAM, acceso root y una cuenta sudo no root. Puede configurar esto siguiendo la Guía de configuración inicial para servidores de Ubuntu 18.04.

      • Nginx instalado en su servidor. En los pasos 1 a 4 de Cómo instalar Nginx en Ubuntu 18.04, encontrará indicaciones para hacer esto.

      • Un nombre de dominio registrado por completo para alojar code-server, orientado a su servidor. En este tutorial, se utilizará code-server.your-domain​​​ en todo momento. Puede adquirir un nombre de dominio en Namecheap, obtener uno gratuito en Freenom o utilizar un registrador de dominios que elija.

      • Los dos registros DNS que se indican a continuación se han configurado para su servidor. Puede utilizar esta introducción al DNS de DigitalOcean para obtener más información sobre cómo agregarlos.

        • Un registro A con your-domain orientado a la dirección IP pública de su servidor.
        • Un registro A con www.your-domain​​​1​​​ orientado a la dirección IP pública de su servidor.

      Paso 1: Instalar code-server

      Cree el directorio para almacenar todos los datos para code-server:

      Diríjase a este:

      Visite la página de versiones de Github de code-server y seleccione la última compilación de Linux. Descárguela usando lo siguiente:

      • wget https://github.com/cdr/code-server/releases/download/2.1692-vsc1.39.2/code-server2.1692-vsc1.39.2-linux-x86_64.tar.gz

      Desempaque el archivo:

      • tar -xzvf code-server2.1692-vsc1.39.2-linux-x86_64.tar.gz

      Diríjase al directorio que contiene el ejecutable de code-server:

      • cd code-server2.1692-vsc1.39.2-linux-x86_64

      Para acceder al ejecutable de code-server en su sistema, cópielo con lo siguiente:

      • sudo cp code-server /usr/local/bin

      Cree una carpeta para que code-server almacene los datos del usuario:

      • sudo mkdir /var/lib/code-server

      Cree un servicio systemd, code-server.service, en el directorio /lib/systemd/system:

      • sudo nano /lib/systemd/system/code-server.service

      Añada las siguientes líneas:

      /lib/systemd/system/code-server.service

      [Unit]
Description=code-server
After=nginx.service

[Service]
Type=simple
Environment=PASSWORD=your_password
ExecStart=/usr/local/bin/code-server --host 127.0.0.1 --user-data-dir /var/lib/code-server --auth password
Restart=always

[Install]
WantedBy=multi-user.target
      • --host 127.0.0.1 lo vincula a localhost.
      • --user-data-dir /var/lib/code-server establece su directorio de datos de usuario.
      • --auth password especifica que debe autenticar a los visitantes con una contraseña.

      Recuerde sustituir your_password por la contraseña que elija.

      Guarde y cierre el archivo.

      Inicie el servicio code-server:

      • sudo systemctl start code-server

      Compruebe que se haya iniciado correctamente:

      • sudo systemctl status code-server

      Verá un resultado similar al siguiente:

      Output
      ● code-server.service - code-server
   Loaded: loaded (/lib/systemd/system/code-server.service; disabled; vendor preset: enabled)
   Active: active (running) since Mon 2019-12-09 20:07:28 UTC; 4s ago
 Main PID: 5216 (code-server)
    Tasks: 23 (limit: 2362)
   CGroup: /system.slice/code-server.service
           ├─5216 /usr/local/bin/code-server --host 127.0.0.1 --user-data-dir /var/lib/code-server --auth password
           └─5240 /usr/local/bin/code-server --host 127.0.0.1 --user-data-dir /var/lib/code-server --auth password
...

      Habilite el servicio code-server para que se inicie automáticamente después de un reinicio del servidor:

      • sudo systemctl enable code-server

      Paso 2: Exponer code-server

      Ahora, configurará Nginx como un proxy inverso para code-server.

      Cree code-server.conf para almacenar la configuración para exponer code-server en su dominio:

      • sudo nano /etc/nginx/sites-available/code-server.conf

      Añada las siguientes líneas para configurar el bloque de su servidor con las directivas necesarias:

      /etc/nginx/sites-available/code-server.conf

      server {
    listen 80;
    listen [::]:80;

    server_name code-server.your_domain;

    location / {
        proxy_pass http://localhost:8080/;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection upgrade;
        proxy_set_header Accept-Encoding gzip;
    }
}

      Sustituya code-server.your_domain por el dominio de su elección; luego guarde y cierre el archivo.

      Para activar esta configuración del sitio, cree un enlace simbólico de la misma:

      • sudo ln -s /etc/nginx/sites-available/code-server.conf /etc/nginx/sites-enabled/code-server.conf

      Pruebe la validez de la configuración:

      Verá el siguiente resultado:

      Output
      nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

      Para que la configuración se aplique, reinicie Nginx:

      • sudo systemctl restart nginx

      Paso 3: Proteger su dominio

      Ahora, protegerá su dominio utilzando un certificado TLS de Let´s Encrypt.

      Añada el repositorio de paquetes de Certbot a su servidor:

      • sudo add-apt-repository ppa:certbot/certbot

      Instale Certbot y su complemento de Nginx:

      • sudo apt install python-certbot-nginx

      Configure ufw para aceptar tráfico cifrado:

      El resultado será lo siguiente:

      Output
      Rule added
Rule added (v6)

      Realice la carga de nuevo para que la configuración se aplique:

      El resultado será el siguiente:

      Output
      Firewall reloaded

      Diríjase a su dominio de code-server.

      Solicitud de inicio de sesión para code-server

      Introduzca su contraseña de code-server. Verá la interfaz expuesta en su dominio.

      GUI de code-server

      Para protegerla, instale un certificado TLS de Let´s Encrypt usando Certbot.

      Solicite un certificado para su dominio con lo siguiente:

      • sudo certbot --nginx -d code-server.your_domain

      Proporcione una dirección de correo electrónico para los avisos urgentes, acepte las Condiciones de servicio de la EFF y decida si todo el tráfico HTTP se redirecciona a HTTPS.

      El resultado tendrá un aspecto similar a este:

      Output
      IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/code-server.your_domain/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/code-server.your_domain/privkey.pem
   Your cert will expire on ... To obtain a new or tweaked
   version of this certificate in the future, simply run certbot again
   with the "certonly" option. To non-interactively renew *all* of
   your certificates, run "certbot renew"
...

      Así, Certbot generó con éxito certificados TLS y los aplicó en la configuración de Nginx para su dominio.

      Conclusión

      Ahora dispone de code-server, un IDE en la nube versátil, instalado en su servidor de Ubuntu 18.04, expuesto en su dominio y protegido con certificados de Let´s Encrypt. Para obtener más información, consulte la documentación de Visual Studio Code sobre características adicionales e instrucciones detalladas relacionadas con otros componentes de code-server.



      Source link

      Como Usar o Git: Um Guia de Consulta Rápida


      Introdução

      Equipes de desenvolvedores e mantenedores de software open-source geralmente gerenciam seus projetos através do Git, um sistema distribuído de controle de versão que suporta colaboração.

      Este artigo no estilo de Guia de Consulta Rápida fornece uma referência de comandos que são úteis para o trabalho e colaboração em um repositório Git. Para instalar e configurar o Git, certifique-se de ler “How To Contribute to Open Source: Getting Started with Git.”

      Como utilizar esse guia:

      • Este guia está no formato de Guia de Consulta Rápida com fragmentos de linha de comando autocontidos.

      • Pule para qualquer seção que seja relevante para a tarefa que você está tentando completar.

      • Quando você vir texto destacado nos comandos deste guia, tenha em mente que este texto deve se referir aos commits e arquivos em seu próprio repositório.

      Configuração e Inicialização

      Verifique a versão do Git com o seguinte comando, que irá também confirmar que o git está instalado.

      Você pode inicializar seu diretório de trabalho atual como um repositório Git com o init.

      Para copiar um repositório Git existente hospedado remotamente, você irá utilizar git clone com a URL do repositório ou a localização do servidor (no último caso você irá usar ssh).

      • git clone https://www.github.com/username/nome-do-repositório

      Mostrar o repositório remoto do seu diretório Git atual.

      Para uma saída mais detalhada, use a flag -v.

      Adicionar o Git upstream, que pode ser uma URL ou pode estar hospedado em um servidor (no último caso, conecte com ssh).

      • git remote add upstream https://www.github.com/username/nome-do-repositório

      Staging

      Quando você modificou um arquivo e o marcou para ir no próximo commit, ele é considerado um arquivo preparado ou staged.

      Verifique o status do seu repositório Git, incluindo arquivos adicionados que não estão como staged, e arquivos que estão como staged.

      Para colocar como staged os arquivos modificados, utilize o comando add, que você pode executar diversas vezes antes de fazer um commit. Se você fizer alterações subsequentes que queira ver incluídas no próximo commit, você deve exwcutar add novamente.

      Você pode especificar o arquivo exato com o add.

      Com o . você pode adicionar todos os arquivos no diretório atual incluindo arquivos que começam com um ..

      Você pode remover um arquivo da área de staging enquanto mantém as alterações no seu diretório de trabalho com reset.

      Fazendo Commit

      Um vez que você tenha colocado no stage a suas atualizações, você está pronto para fazer o commit delas, que irá gravar as alterações que você fez no repositório.

      Para fazer commit dos arquivos em stage, você irá executar o comando commit com sua mensagem de confirmação significativa para que você possa rastrear os commits.

      • git commit -m "Mensagem de commit"

      Você pode condensar o staging de todos os arquivos rastreados fazendo o commit deles em uma única etapa.

      • git commit -am "Mensagem de commit"

      Se você precisar modificar a sua mensagem de commit, você pode fazer isto com a flag --amend.

      • git commit --amend -m "Nova Mensagem de commit"

      Branches ou Ramificações

      Uma branch ou ramificação é um ponteiro móvel para um dos commits no repositório. Ele lhe permite isolar o trabalho e gerenciar o desenvolvimento de recursos e integrações. Você pode aprender mais sobre branches através da leitura da documentação do Git.

      Listar todas as branches atuais com o comando branch. Um aterisco (*) irá aparecer próximo à sua branch ativa atualmente.

      Criar uma nova branch. Você permanecerá na sua branch ativa até mudar para a nova.

      Alternar para qualquer branch existente e fazer checkout em seu diretório de trabalho atual.

      • git checkout outra-branch

      Você pode consolidar a criação e o checkout de uma nova branch utilizando a flag -b.

      • git checkout -b nova-branch

      Renomear a sua branch.

      • git branch -m nome-da-branch-atual novo-nome-da-branch

      Mesclar o histórico da branch especificada àquela em que você está trabalhando atualmente.

      Abortar a mesclagem, no caso de existirem conflitos.

      Você também pode selecionar um commit particular para mesclar com cherry-pick e com a string que referencia o commit específico.

      Quando você tiver mesclado uma branch e não precisar mais dela, poderá excluí-la.

      • git branch -d nome-da-branch

      Se você não tiver mesclado uma branch com o master, mas tiver certeza de que deseja excluí-la, poderá forçar a exclusão da branch.

      • git branch -D nome-da-branch

      Colaborar e Atualizar

      Para baixar alterações de outro repositório, tal como o upstream remoto, você irá usar o fetch.

      Mesclar os commits baixados.

      • git merge upstream/master

      Envie ou transmita seus commits na branch local para a branch do repositório remoto.

      Busque e mescle quaisquer commits da branch remota de rastreamento.

      Inspecionando

      Mostrar o histórico de commits para a branch ativa atualmente.

      Mostrar os commits que alteraram um arquivo particular. Isso segue o arquivo, independentemente da renomeação do mesmo.

      • git log --follow meu_script.py

      Mostrar os commits que estão em uma branch e não estão em outra. Isto irá mostrar os commits em a-branch que não estão em b-branch.

      • git log a-branch..b-branch

      Observe os logs de referência (reflog) para ver quando as dicas de branches e outras referências foram atualizadas pela última vez dentro do repositório.

      Mostrar qualquer objeto no Git através da sua string de commit ou hash em um formato mais legível.

      Mostrar Alterações

      O comando git diff mostra as alterações entre commits, branches, entre outras. Você pode ler mais detalhadamente sobre isso através da Documentação do Git.

      Comparar arquivos modificados que estão na área de staging.

      Exibe o diff do que está em a-branch mas não está em b-branch.

      • git diff a-branch..b-branch

      Mostrar o diff entre dois commits específicos.

      • git diff 61ce3e6..e221d9c

      Stashing

      Às vezes, você descobrirá que fez alterações em algum código, mas, antes de terminar, precisa começar a trabalhar em outra coisa. Você ainda não está pronto para fazer o commit das alterações que você fez até agora, mas não quer perder seu trabalho. O comando git stash lhe permitirá salvar suas modificações locais e reverter para o diretório de trabalho que está alinhado com o commit mais recente do HEAD.

      Guarde (stash) seu trabalho atual.

      Veja o que você tem guardado atualmente.

      Seus rascunhos serão nomeados stash@{0}, stash@{1}, e assim por diante.

      Mostrar informações sobre um rascunho em particular.

      Para trazer os arquivos de um rascunho atual enquanto mantém o rascunho guardado, utilize apply.

      • git stash apply stash@{0}

      Se você quer trazer os arquivos de uma rascunho e não precisa mais do rascunho, utilize pop.

      Se você não precisar mais dos arquivos salvos em um determinado rascunho ou stash, você pode descartar o rascunho com drop.

      Se você tiver muitos rascunhos salvos e não precisar mais de nenhum deles, você pode utilizar clear para removê-los.

      Ignorando Arquivos

      Se você quiser manter arquivos em seu diretório local do Git, mas não quer fazer o commit deles no projeto, você pode adicionar esses arquivos ao seu arquvo .gitignore para que não causem conflitos.

      Utilize um editor de textos como o nano para adicionar arquivos ao arquivo .gitignore.

      Para ver exemplos de arquivos .gitignore, você pode olhar o repositório de modelos .gitignore do GitHub.

      Rebasing

      Um rebase nos permite mover as branches alterando o commit no qual elas são baseadas. Como o rebasing, você pode reescrever ou reformular os commits.

      Você pode iniciar um rebase chamando o número de commits que você fez e que você quer fazer rebase (5 no caso abaixo).

      Como alternativa, você pode fazer o rebase com base em uma determinada string de commit ou hash.

      Depois de ter reescrito ou reformulado os commits, você pode concluir o rebase da sua branch em cima da versão mais recente do código upstream do projeto.

      • git rebase upstream/master

      Para aprender mais sobre rabase e atualização, você pode ler How To Rebase and Update a Pull Request, que também é aplicável a qualquer tipo de commit.

      Resetando

      Às vezes, inclusive após um rebase, você precisa redefinir sua árvore de trabalho. Você pode redefinir ou resetar para um commit específico e excluir todas as alterações com o seguinte comando.

      Para forçar a enviar seu último commit conhecido e não conflitante para o repositório de origem, você precisará usar o --force.

      Atenção: Forçar o envio ou pushing para o master não é muito aprovado a menos que haja uma razão realmente importante para fazê-lo. Use isso com moderação ao trabalhar em seus próprios repositórios e evite fazer isso quando estiver colaborando.

      • git push --force origin master

      Para remover arquivos e subdiretórios locais não rastreados do diretório Git para uma branch de trabalho limpa, você pode usar git clean.

      Se você precisar modificar seu repositório local para que ele pareça com o upstream master atual (isto é, quando há muitos conflitos), você pode executar um hard reset.

      Nota: Executar este comando fará com que seu repositório local fique exatamente igual ao upstream. Todos os commits que você fez, mas que não foram enviados para o upstream, serão destruídos.

      • git reset --hard upstream/master

      Conclusão

      Este guia aborda alguns dos comandos mais comuns do Git que você pode usar ao gerenciar repositórios e colaborar em software.

      Você pode aprender mais sobre software open-source e colaboração em nossa série de tutoriais Introduction to Open Source:

      Existem muitos outros comandos e variações que você pode achar úteis como parte do seu trabalho com o Git. Para saber mais sobre todas as opções disponíveis, você pode executar o comando abaixo receber informações úteis:

      Você também pode ler mais sobre o Git e ver a documentação dele no website oficial do Git.

      Por Lisa Tagliaferri



      Source link

      Forgot Your Password ?