Atualizado em 10/01/2020. Pouco mais de um ano se passou desde a redação do artigo e vários exemplos pararam de funcionar - as tecnologias estão se desenvolvendo, por isso acrescentei e refiz um pouco os exemplos.Neste artigo, gostaria de falar sobre a instalação do Kubernetes na nuvem Hetzner.
O Ubuntu Linux 18.04 está instalado no meu computador de trabalho e todos os exemplos implicam o uso deste sistema operacional.
Para trabalhar com o Hetzner Cloud e criar um cluster Kubernetes, usaremos o
utilitário hetzner-kube . Instale-o no seu computador local.
$ wget https://github.com/xetys/hetzner-kube/releases/download/0.5.1/hetzner-kube-0.5.1-linux-amd64 $ chmod a+x ./hetzner-kube-0.5.1-linux-amd64 $ sudo mv ./hetzner-kube-0.5.1-linux-amd64 /usr/local/bin/hetzner-kube
Para usar o utilitário hetzner-kube e autorizá-lo na Hetzner Cloud, você precisa criar a API de token por meio do Hetzner Cloud Console
https://console.hetzner.cloud . Na parte superior, selecione Selecionar um projeto -> Padrão, selecione o item Acesso no menu esquerdo e vá para a seção Tokens de API, clique no botão Gerar token de API.
Como resultado, a API de token será gerada e precisará ser especificada na configuração do utilitário hetzner-kube.
$ hetzner-kube context add k8s Token: <PASTE TOKEN HERE> added context 'k8s'
Em seguida, precisamos gerar uma chave SSH que será usada para acessar os servidores na nuvem Hetzner. Para fazer isso, use o utilitário ssh-keygen:
$ ssh-keygen -t rsa Generating public/private rsa key pair. Enter file in which to save the key (~/.ssh/id_rsa): Enter passphrase (empty for no passphrase): Enter same passphrase again: Your identification has been saved in ~/.ssh/id_rsa. Your public key has been saved in ~/.ssh/id_rsa.pub. The key fingerprint is: SHA256:1bwptZ8lPiAhtA37/2U1G7HsC+aE7qMVCtVIfN3OLzk lx4241@LX4241-LINUX The key's randomart image is: +---[RSA 2048]----+ | +. . . | | ..*o+ . . | | +o=.+ o. | | .+ o +.oo| | .S +.= .*+| | . .+o+E+*| | . o.+==o| | o.+..+.| | .oo.... | +----[SHA256]-----+
Como resultado, dois arquivos ~ / .ssh / id_rsa (chave privada) e ~ / .ssh / id_rsa.pub (chave pública) serão criados no seu diretório pessoal.
Adicione a chave pública ssh à nuvem Hetzner:
$ hetzner-kube ssh-key add --name k8s sshKeyAdd called SSH key k8s(95430) created
Criar um cluster Kubernetes diretamente é muito fácil:
$ hetzner-kube cluster create --name k8s --ssh-key k8s --master-count 1 --worker-count 1 2018/08/02 13:57:57 Creating new cluster NAME:k8s MASTERS: 1 WORKERS: 1 ETCD NODES: 0 HA: false ISOLATED ETCD: false 2018/08/02 13:57:58 creating server 'k8s-master-01'... --- [======================================] 100% 2018/08/02 13:58:18 Created node 'k8s-master-01' with IP 159.69.54.228 2018/08/02 13:58:18 creating server 'k8s-worker-01'... --- [======================================] 100% 2018/08/02 13:58:37 Created node 'k8s-worker-01' with IP 159.69.51.140 2018/08/02 13:58:37 sleep for 10s... k8s-master-01 : complete! 100.0% [==============] k8s-worker-01 : complete! 100.0% [==============] 2018/08/02 14:02:50 Cluster successfully created!
Este comando criará automaticamente servidores virtuais na nuvem Hetzner e instalará o número especificado de nós principais / trabalhadores do cluster Kubernetes neles. Por padrão, os servidores virtuais CX11 serão usados.
Posteriormente, usando o utilitário hetzner-kube, também é fácil alterar a configuração do cluster Kubernetes adicionando nós de trabalho. Por exemplo, adicione 2 nós de trabalho:
$ hetzner-kube cluster add-worker --name k8s --nodes 2
Infelizmente, atualmente não é possível alterar a configuração do nó principal usando o utilitário hetzner-kube sem reconstruir completamente o cluster Kubernetes.
O utilitário kubectl é usado para trabalhar com o cluster Kubernetes. Instruções detalhadas para instalá-lo em diferentes sistemas operacionais podem ser encontradas
no seguinte link .
Para trabalhar com o cluster Kubernetes criado usando o comando kubectl, você deve salvar a configuração do cluster criado localmente da seguinte maneira:
$ hetzner-kube cluster kubeconfig k8s create file kubeconfig configured
O arquivo de configuração é salvo em ~ / .kube / config.
Agora vamos para a parte mais interessante - a configuração do cluster Kubernetes resultante.
Para começar, criaremos os recursos básicos necessários para futura implantação de aplicativos. Você pode encontrar informações mais detalhadas no
seguinte link .
$ curl https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-0.26.2/deploy/static/mandatory.yaml | kubectl apply -f - % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 6170 100 6170 0 0 13987 0 --:--:-- --:--:-- --:--:-- 14022 namespace/ingress-nginx created configmap/nginx-configuration created configmap/tcp-services created configmap/udp-services created serviceaccount/nginx-ingress-serviceaccount created clusterrole.rbac.authorization.k8s.io/nginx-ingress-clusterrole created role.rbac.authorization.k8s.io/nginx-ingress-role created rolebinding.rbac.authorization.k8s.io/nginx-ingress-role-nisa-binding created clusterrolebinding.rbac.authorization.k8s.io/nginx-ingress-clusterrole-nisa-binding created deployment.apps/nginx-ingress-controller created limitrange/ingress-nginx created $ curl https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-0.26.2/deploy/static/provider/baremetal/service-nodeport.yaml | kubectl apply -f - service/ingress-nginx created
Além disso, é necessário que o controlador de ingresso esteja acessível a nós pela Internet. Para fazer isso, use o utilitário kubectl para editar service / ingress-nginx e adicione a ele a lista de endereços IP públicos do nó trabalhador / mestre do cluster Kubernetes (apenas aqueles que queremos usar para processar solicitações de entrada da Internet).
$ kubectl -n ingress-nginx edit service/ingress-nginx
e adicione a próxima seção ao manifesto YAML
spec: externalIPs: - XXXX - YYYY
Adicione registros A ao seu domínio e aguarde até que as informações sobre eles apareçam na CSN. Por exemplo:
Type: A Name: echo.example.com Value: XXXX
Se você especificou vários endereços IP externos em ingress-nginx.yaml, poderá criar vários registros DNS idênticos com esses endereços IP. Nesse caso, as solicitações para seu domínio serão distribuídas entre esses endereços IP e o balanceamento de carga ocorrerá.
Neste exemplo, para que o https funcione, geraremos um certificado SSL autoassinado.
$ openssl req -newkey rsa:2048 -nodes -keyout echo.example.com.key -x509 -days 365 -out echo.example.com.crt Generating a 2048 bit RSA private key ..+++ .............+++ writing new private key to 'echo.example.com.key' ----- You are about to be asked to enter information that will be incorporated into your certificate request. What you are about to enter is what is called a Distinguished Name or a DN. There are quite a few fields but you can leave some blank For some fields there will be a default value, If you enter '.', the field will be left blank. ----- Country Name (2 letter code) [AU]:UA State or Province Name (full name) [Some-State]:Kyiv Locality Name (eg, city) []:Kyiv Organization Name (eg, company) [Internet Widgits Pty Ltd]:Super Company Ltd Organizational Unit Name (eg, section) []:echo.example.com Common Name (eg server FQDN or YOUR name) []:echo.example.com Email Address []:info@echo.example.com $ cat echo.example.com.key | base64 | tr -d '\n' <YOUR PRIVATE KEY> $ cat echo.example.com.crt | base64 | tr -d '\n' <YOUR CERTIFICATE>
Agora adicionamos nossa aplicação. Um echoserver simples foi escolhido como exemplo. Crie um arquivo chamado app.yaml com o seguinte conteúdo:
apiVersion: v1 kind: Namespace metadata: name: echoserver --- apiVersion: v1 kind: Secret metadata: name: echo.example.com-tls namespace: echoserver type: kubernetes.io/tls data: tls.crt: <YOUR CERTIFICATE> tls.key: <YOUR PRIVATE KEY> --- apiVersion: apps/v1 kind: Deployment metadata: name: echoserver namespace: echoserver spec: replicas: 1 selector: matchLabels: app: echoserver template: metadata: labels: app: echoserver spec: containers: - image: gcr.io/google_containers/echoserver:1.0 imagePullPolicy: Always name: echoserver ports: - containerPort: 8080 --- apiVersion: v1 kind: Service metadata: name: echoserver namespace: echoserver spec: ports: - name: http port: 80 targetPort: 8080 protocol: TCP selector: app: echoserver --- apiVersion: extensions/v1beta1 kind: Ingress metadata: name: echoserver namespace: echoserver annotations: kubernetes.io/ingress.class: "nginx" spec: tls: - hosts: - echo.example.com secretName: echo.example.com-tls rules: - host: echo.example.com http: paths: - path: / backend: serviceName: echoserver servicePort: 80
$ kubectl apply -f app.yaml namespace "echoserver" configured deployment "echoserver" unchanged service "echoserver" configured ingress "echoserver" unchanged
Isso é tudo)) Verifique o resultado:
$ curl https://echo.example.com/ CLIENT VALUES: client_address=('10.244.3.2', 32860) (10.244.3.2) command=GET path=/ real path=/ query= request_version=HTTP/1.1 SERVER VALUES: server_version=BaseHTTP/0.6 sys_version=Python/3.5.0 protocol_version=HTTP/1.0 HEADERS RECEIVED: Accept=*/* Connection=close Host=echo.example.com User-Agent=curl/7.58.0 X-Forwarded-For=10.244.0.0 X-Forwarded-Host=echo.example.com X-Forwarded-Port=80 X-Forwarded-Proto=http X-Original-URI=/ X-Real-IP=10.244.0.0 X-Request-ID=7a4f4aabf9a0043ea2b1ca91bd1a3adf X-Scheme=http