Cómo generar un certificado autofirmado para Kubernetes

Introducción

En 2020, Google Chrome cambió el comportamiento de SameSite=None cookies para requerir la activación de Secure opción. Como resultado, probar un cliente de interfaz de usuario web cuyo backend API se ejecuta en un clúster local de Kubernetes ahora requiere acceso HTTPS.

En este tutorial, aprenderá a obtener acceso HTTPS mediante la generación de un certificado autofirmado para Kubernetes mediante los métodos cert-manager, CFSSL, Easy-RSA y OpenSSL.

Requisitos previos

• Un clúster de Kubernetes (puedes crearlo usando minikube)
• herramienta de línea de comandos kubectl instalada

Generación de certificados mediante cert-manager

Como controlador de gestión de certificados nativo de Kubernetes, cert-manager complemento es la forma más común de generar certificados autofirmados.

Paso 1:Instale el administrador de certificados

Para instalar cert-manager, primero cree un espacio de nombres para él:

kubectl create namespace cert-manager

A continuación, utilice kubectl apply comando y yaml archivo disponible en línea para instalar el complemento:

kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v0.13.1/cert-manager.yaml

Paso 2:crear un emisor de certificados

Crear un espacio de nombres donde generarás certificados:

kubectl create namespace [namespace]

A continuación, defina un emisor de certificados escribiendo el siguiente comando de varias líneas en la terminal:

kubectl apply -n [namespace] -f <(echo "
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
  name: [issuer-name]
spec:
  selfSigned: {}
")

El resultado confirma la creación exitosa del emisor:

Un emisor creado de esta manera solo funciona para el espacio de nombres actual. Si desea poder solicitar certificados de cualquier espacio de nombres en un clúster, cree un recurso de Kubernetes personalizado llamado ClusterIssuer usando el selfsigned-issuer.yaml disponible archivo:

kubectl apply -f https://gist.githubusercontent.com/t83714/51440e2ed212991655959f45d8d037cc/raw/7b16949f95e2dd61e522e247749d77bc697fd63c/selfsigned-issuer.yaml

Paso 3:generar un certificado

Genere un certificado autofirmado escribiendo el siguiente comando de varias líneas en el terminal:

kubectl apply -n [namespace]-f <(echo '
apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
  name: [certificate-name]
spec:
  secretName: [secret-name]
  dnsNames:
  - "*.[namespace].svc.cluster.local"
  - "*.[namespace]"
  issuerRef:
    name: [issuer-name]
')

El resultado confirma que la creación fue exitosa:

Para comprobar el certificado que ha creado, escriba:

kubectl -n [namespace] get certificate

Para ver información sobre el Secreto, use el get secret comando:

kubectl -n [namespace] get secret [secret-name]

Las tres claves contenidas en este secreto son ca.crt , tls.crt y tls.key . Para el secreto completo, escriba:

kubectl -n [namespace] get secret [secret-name] -o yaml

Paso 4:probar el certificado

Utilice el siguiente comando para probar la validez del certificado:

openssl x509 -in <(kubectl -n [namespace] get secret \
  first-tls -o jsonpath='{.data.tls\.crt}' | base64 -d) \
  -text -noout

El X509v3 Subject Alternative Name la línea debe contener dnsNames proporcionó durante la generación del certificado.

Generación de certificados a través de CFSSL

Otra herramienta común para generar y verificar certificados autofirmados es CFSSL. . La herramienta consta de cuatro programas:

• cfssl – una utilidad de línea de comandos para la gestión de paquetes CFSSL.
• multirootca – un servidor de autoridad certificadora.
• mkbundle – un generador de paquetes de grupos de certificados.
• cfssljson – un generador de certificados que utiliza json salidas de cfssl y multirootca .

Los pasos a continuación muestran cómo generar un certificado autofirmado mediante CFSSL.

Paso 1:Instale CFSSL usando Go

Para instalar CFSSL, primero debe instalar los paquetes de idioma Go necesarios. Escribe el siguiente comando:

sudo apt install golang

Luego, use la sintaxis Go para descargar cfssl :

go get -u github.com/cloudflare/cfssl/cmd/cfssl

A continuación, copie el archivo de ~/go/bin a la carpeta apropiada:

sudo cp ~/go/bin/cfssl /usr/local/bin/cfssl

Finalmente, repita el proceso con cfssljson :

go get -u github.com/cloudflare/cfssl/cmd/cfssljson
sudo cp ~/go/bin/cfssljson /usr/local/bin/cfssljson

Paso 2:crear una autoridad de certificación

Después de instalar los programas, continúe con la creación de una autoridad de certificación (CA) autofirmada. El siguiente ejemplo crea un archivo llamado ca.json .

El archivo define lo siguiente:

• CN – Nombre común de la autoridad
• algo – el algoritmo utilizado para los certificados
• size – tamaño del algoritmo en bits
• C – País
• L – Localidad (ciudad)
• ST – Estado o provincia
• O – Organización
• OU – Unidad organizativa

El siguiente ejemplo es para la organización llamada "Empresa de ejemplo" y su unidad organizativa "Empresa de ejemplo CA raíz" con sede en Nueva York, NY, Estados Unidos.

{
  "CN": "Example Company Root CA",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
  {
    "C": "US",
    "L": "New York",
    "ST": "New York",
    "O": "Example Company",
    "OU": "Example Company Root CA"
  }
 ]
}

Crea y guarda el json archivo en un editor de texto. Luego, utilícelo para generar el ca.pem y ca-key.pem archivos escribiendo lo siguiente cfssl comando:

cfssl gencert -initca ca.json | cfssljson -bare ca

Paso 3:Cree el archivo de configuración

Para continuar, cree el cfssl.json archivo de configuración. El archivo proporciona detalles sobre la fecha de caducidad del certificado y el uso para perfiles separados (par, servidor y cliente).

cfssl.json debería verse así:

{
  "signing": {
    "default": {
      "expiry": "8760h"
    },
    "profiles": {
      "intermediate_ca": {
        "usages": [
            "signing",
            "digital signature",
            "key encipherment",
            "cert sign",
            "crl sign",
            "server auth",
            "client auth"
        ],
        "expiry": "8760h",
        "ca_constraint": {
            "is_ca": true,
            "max_path_len": 0, 
            "max_path_len_zero": true
        }
      },
      "peer": {
        "usages": [
            "signing",
            "digital signature",
            "key encipherment", 
            "client auth",
            "server auth"
        ],
        "expiry": "8760h"
      },
      "server": {
        "usages": [
          "signing",
          "digital signing",
          "key encipherment",
          "server auth"
        ],
        "expiry": "8760h"
      },
      "client": {
        "usages": [
          "signing",
          "digital signature",
          "key encipherment", 
          "client auth"
        ],
        "expiry": "8760h"
      }
    }
  }
}

Guardar el archivo y salir.

Paso 4:crear una autoridad de certificación intermedia

Otro json el archivo que debe crear es intermediate-ca.json . Define la autoridad de certificación intermedia y tiene un aspecto similar al ca.json creado anteriormente. :

{
  "CN": " Example Company Intermediate CA",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "US",
      "L": "New York",
      "ST": "New York",
      "O": "Example Company",
      "OU": "Example Company Intermediate CA"
    }
  ],
  "ca": {
    "expiry": "42720h"
  }
}

Paso 5:Firme el Certificado

Después de crear ambos archivos, escriba el siguiente comando para crear el intermediate_ca.pem , intermediate_ca.csr y intermediate_ca-key.pem y firme la CA intermedia:

cfssl gencert -initca intermediate-ca.json | cfssljson -bare intermediate_ca

Luego, firme el certificado usando la CA y el archivo de configuración cfssl.json:

cfssl sign -ca ca.pem -ca-key ca-key.pem -config cfssl.json -profile intermediate_ca intermediate_ca.csr | cfssljson -bare intermediate_ca

Paso 6:generar certificados de host

Para generar certificados de host para perfiles de pares, servidores y clientes, cree el host1.json archivo con la información necesaria sobre los hosts.

{
  "CN": "host.example-company.com",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "US",
      "L": "New York",
      "O": "Example Company",
      "OU": "Example Company Intermediate CA",
      "ST": "New York"
    }

  ],
  "hosts": [
    "host1.example-company.com",
    "localhost"
  ]
}

Ahora, genere los certificados utilizando el archivo de configuración que creó. Para el certificado de pares que permite la comunicación entre servidores, escriba:

cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=peer host1.json | cfssljson -bare host-1-peer

Para generar un certificado de servidor, escriba:

cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=server host1.json | cfssljson -bare host-1-server

La sintaxis de un certificado de cliente, que a menudo no se requiere pero es compatible con algunos sistemas, es:

cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=client host1.json | cfssljson -bare host-1-client

Los resultados respectivos confirman la generación exitosa de los certificados.

Generación de certificados a través de Easy-RSA

Easy-RSA es una utilidad popular para crear autoridades de certificación raíz, solicitar y firmar certificados.

Paso 1:Instale Easy-RSA

Para descargar paquetes Easy-RSA, necesita curl. Si no tiene curl instalado, instálelo escribiendo:

sudo apt install curl

Ahora, escribe el siguiente comando curl:

Curl -LO https://storage.googleapis.com/kubernetes-release/easy-rsa/easy-rsa.tar.gz

Descomprima el archivo que descargó:

tar xzf easy-rsa.tar.gz

Vaya a easy-rsa-3.0.1/easyrsa3 directorio:

cd easy-rsa-master/easyrsa3

Una vez que esté en la carpeta, escriba el siguiente comando para terminar de configurar Easy-RSA:

./easyrsa init-pki

Paso 2:Cree una CA autofirmada

Para iniciar la creación de una CA autofirmada, use este comando:

./easyrsa build-ca

El sistema le pide que escriba una frase de contraseña PEM para cifrar ca.key expediente. A continuación, el mensaje le solicita que ingrese información sobre la CA que está creando.

Paso 3:generar el certificado y la clave del servidor

El siguiente paso es generar un certificado de servidor y una clave mediante un comando de varias líneas que se muestra a continuación. El --subject-alt-name La opción establece las direcciones IP y los nombres DNS para acceder al servidor API.

Los --days La opción controla la duración de la validez del certificado.

cluster.local es el nombre de dominio DNS predeterminado.

./easyrsa --subject-alt-name="IP:[master-IP-address]," \
"IP:[master-cluster-IP-address]," \
"DNS:kubernetes," \
"DNS:kubernetes.default," \
"DNS:kubernetes.default.svc," \
"DNS:kubernetes.default.svc.cluster," \
"DNS:kubernetes.default.svc.cluster.local" \ 
--days=10000 \
build-server-full server nopass

El sistema le pide que repita la frase de contraseña que creó en el paso anterior. Luego, la salida confirma que la base de datos se actualizó con una nueva entrada. Copie el pki/ca.crt , pki/issued/server.crt y pki/private/server.key archivos a su directorio.

Generación de certificados a través de OpenSSL

OpenSSL le permite generar certificados TLS manualmente. Los siguientes pasos muestran cómo usar OpenSSL para generar claves y certificados para su clúster.

Paso 1:Instalar OpenSSL

El OpenSSL La herramienta suele estar preinstalada en los sistemas Linux. Comprueba si lo tienes instalado escribiendo:

openssl version -a

La salida se ve así:

Si recibe un mensaje que dice que no tiene OpenSSL en su sistema, instale la herramienta con el administrador de paquetes de su distribución.

Por ejemplo:

sudo apt install openssl

Paso 2:generar los archivos de certificado

Utilice el siguiente comando para generar una clave cifrada RSA de 2048 bits para la firma del certificado:

openssl genrsa -out ca.key 2048

Ahora, usa la ca.key para generar ca.crt . Usa los -days opción para establecer la duración de la validez del certificado:

openssl req -x509 -new -nodes -key ca.key -subj "/CN=[master-ip-address]" -days [number] -out ca.crt

Si no se producen errores, el comando no genera ningún resultado.

Finalmente, genere el server.key archivo con cifrado RSA de 2048 bits:

openssl genrsa -out server.key 2048

Paso 3:Cree el archivo de configuración del certificado

Crear un csr.conf archivo de configuración para generar una solicitud de firma de certificado (CSR). El archivo de ejemplo a continuación también asume que está utilizando cluster.local como nombre de dominio DNS predeterminado.

[ req ]
default_bits = 2048
prompt = no
default_md = sha256
req_extensions = req_ext
distinguished_name = dn

[ dn ]
C = [country]
ST = [state]
L = [city]
O = [company]
OU = [organization-unit]
CN = [common-name]

[ req_ext ]
subjectAltName = @alt_names

[ alt_names ]
DNS.1 = kubernetes
DNS.2 = kubernetes.default
DNS.3 = kubernetes.default.svc
DNS.4 = kubernetes.default.svc.cluster
DNS.5 = kubernetes.default.svc.cluster.local
IP.1 = [MASTER_IP]
IP.2 = [MASTER_CLUSTER_IP]

[ v3_ext ]
authorityKeyIdentifier=keyid,issuer:always
basicConstraints=CA:FALSE
keyUsage=keyEncipherment,dataEncipherment
extendedKeyUsage=serverAuth,clientAuth
[email protected]_names

Asegúrese de reemplazar las explicaciones entre corchetes con los valores reales. Guarde el archivo y utilícelo para generar una solicitud de firma de certificado:

openssl req -new -key server.key -out server.csr -config csr.conf

El comando no produce ningún resultado, pero crea el server.csr archivo.

Paso 4:Generar el Certificado

Use el archivo que generó en el paso anterior junto con ca.key y ca.crt para crear un certificado de servidor:

openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key \
-CAcreateserial -out server.crt -days 10000 \
-extensions v3_ext -extfile csr.conf

El resultado de este comando de varias líneas confirma la creación del certificado y enumera los datos del archivo de configuración:

Para ver el certificado que creó, escriba:

openssl x509 -noout -text -in ./server.crt