Volcados de memoria en Kubernetes para depurar aplicaciones .NET

Nota: este artículo es una traducción del artículo original "Collecting memory dumps for .NET Core on Kubernetes" de Cezary Piątek en su blog Automation Tycoon, que te recomendamos. Hemos añadido algunos enlaces útiles.

En el mundo de Kubernetes y los microservicios, diagnosticar y depurar problemas puede ser una tarea desafiante. Una potente herramienta en tu arsenal de resolución de problemas es el análisis de volcados de memoria de tus aplicaciones. Los volcados de memoria capturan el estado de la memoria de una aplicación en un momento particular, proporcionando información sobre posibles problemas, cuellos de botella y fallos. Este artículo te guiará a través del proceso de recolección de un volcado de memoria de una aplicación .NET en ejecución en Kubernetes.

Paso 1: Puesta en marcha

Si aún no lo tienes, necesitarás instalar kubectl, la herramienta de línea de comandos de Kubernetes para interactuar con clústeres. Puedes seguir las instrucciones de instalación proporcionadas en la documentación oficial de Kubernetes o utilizar el comando winget si estás en Windows:

winget install Kubernetes.kubectl

Teniendo la herramienta kubectl instalada, comienza identificando los pods relevantes utilizando un selector de etiquetas. Por ejemplo, puedes listar los pods con la etiqueta app.kubernetes.io/instance=EL_NOMBRE_DE_TU_APP en el espacio de nombres NOMBRE_DE_TU_ESPACIO_DE_NOMBRES:

kubectl get pods --selector=app.kubernetes.io/instance=EL_NOMBRE_DE_TU_APP --namespace NOMBRE_DE_TU_ESPACIO_DE_NOMBRES -o=name --kubeconfig "ruta_al_archivo_de_configuración_kubeconfig.yaml"

El parámetro --kubeconfig se utiliza para especificar la ruta al archivo de configuración necesario para autenticarse y poder interactuar con el clúster de Kubernetes. Este archivo contiene información sobre el servidor de API del clúster, las credenciales de autenticación y el contexto. Puedes obtener el archivo kubeconfig de tu administrador de Kubernetes o generarlo por tu cuenta si tienes acceso al clúster. Si estás utilizando Rancher, sigue esta guía para obtener tu archivo kubeconfig.

Paso 2: Accediendo al pod

Para acceder al pod y ejecutar comandos dentro de él, puedes utilizar el comando kubectl exec. Este ejemplo asume que estás accediendo al pod con el nombre NOMBRE_DE_TU_POD:

kubectl exec -it "pod/NOMBRE_DE_TU_POD" --kubeconfig "ruta_al_archivo_de_configuración_kubeconfig.yaml" --namespace NOMBRE_DE_TU_ESPACIO_DE_NOMBRES -- sh

Es posible que necesites descargar dotnet-dump (lo veremos en el próximo paso).

Además, puede que tengas permisos limitados para guardar datos en disco en el contenedor, por lo que sería bueno que ejecutases los próximos pasos desde el directorio /tmp. Navega al directorio /tmp dentro del pod:

cd /tmp

Paso 3: Creando un volcado de memoria

Ahora, procedamos a recolectar el volcado de memoria para la aplicación .NET. Comienza descargando la herramienta dotnet-dump:

curl -L -o dotnet-dump https://aka.ms/dotnet-dump/linux-x64

Otorga los permisos necesarios a la herramienta que acabamos de descargar:

chmod 777 ./dotnet-dump

Especifica un directorio de extracción para la herramienta:

export DOTNET_BUNDLE_EXTRACT_BASE_DIR="/tmp/bundle_extract"

Ahora, inicia la recolección del volcado de memoria. Reemplaza el 1 con el identificador de proceso apropiado de tu aplicación .NET:

./dotnet-dump collect -p 1

El volcado de memoria recolectado se guardará como un archivo con el prefijo core_ y una marca de tiempo, en el directorio /tmp.

Paso 4: Comprimiendo el volcado de memoria

Una vez generado el volcado de memoria, puedes comprimirlo para facilitar su transferencia y análisis:

gzip core_<marca_de_tiempo>

Paso 5: Descargando el volcado de memoria

Ahora que el volcado de memoria está listo, puedes copiarlo desde el pod a tu máquina local utilizando el comando kubectl cp.

Primero necesitas salir de la consola del pod:

exit

De vuelta en la consola de tu quipo local, ejecuta el siguiente comando para descargar el archivo de memoria a tu máquina:

kubectl cp "NOMBRE_DE_TU_POD:/tmp/core_<marca_de_tiempo>.gz" ./core_<marca_de_tiempo>.gz --kubeconfig "ruta_al_archivo_de_configuración_kubeconfig.yaml" --namespace NOMBRE_DE_TU_ESPACIO_DE_NOMBRES

Paso 6: Descomprimiendo el volcado de memoria

Ahora necesitas descomprimir el archivo de volcado de memoria. Puedes hacerlo con 7-Zip o utilizando el script de PowerShell que encontré aquí: Unzip GZ files using Powershell.

Ahora ya estás en disposición para comenzar un análisis de memoria. Puedes hacerlo con Visual Studio (vídeo práctico en inglés), WindDBG (aquí un artículo práctico) o con dotMemory.

Todo a la vez en todas partes

Todo lo descrito anteriormente se puede compilar en un simple script de PowerShell para llevar todo el proceso a una sola ejecución de comando:

param (
  [Parameter(Mandatory=$true)][string] $PodName,
  [Parameter(Mandatory=$true)][string] $Namespace,
  [Parameter(Mandatory=$true)][string] $KubeconfigFile,
  [Parameter(Mandatory=$true)][string] $OutputDirectory
)

Write-Host "Preparando archivo de volcado"

$linuxDumpScript = @"
cd /tmp && \
curl -L -o dotnet-dump https://aka.ms/dotnet-dump/linux-x64 && \
chmod 777 ./dotnet-dump && \
export DOTNET_BUNDLE_EXTRACT_BASE_DIR='/tmp/bundle_extract' && \
./dotnet-dump collect -p 1
"@ -replace "`r`n","`n"

$dumpLog = kubectl exec -it "pod/$PodName" --kubeconfig $KubeconfigFile --namespace "$Namespace" -- sh -c $linuxDumpScript.Trim() 

Write-Host $dumpLog

$pattern = "Writing full to (.*?)Complete"
$matches = [Regex]::Matches($dumpLog, $pattern)

if ($matches.Count -eq 0) {
    Write-Error "No se puede encontrar el nombre del archivo de volcado"
    return
}

$dumpFile = $matches[0].Groups[1].Value.Trim()

Write-Host "Archivo de volcado $($matches[0].Groups[1].Value)"
Write-Host "Comprimiendo archivo de volcado"

kubectl exec -it "pod/$PodName" --kubeconfig $KubeconfigFile --namespace "$Namespace" -- sh -c "gzip $dumpFile" | Out-Host

$fileName = [System.IO.Path]::GetFileName($dumpFile)
$archiveFileName = "$fileName.gz"

if ([string]::IsNullOrWhiteSpace($OutputDirectory)) {
    $OutputDirectory = "."
}

# Se requiere una ruta relativa para `kubectl cp`
$directoryRelativePath = Resolve-Path -Relative $OutputDirectory
$outputFile = Join-Path $directoryRelativePath $archiveFileName
Write-Host "Descargando archivo de volcado a $outputFile"

kubectl cp "$PodName`:$dumpFile`.gz" $outputFile --kubeconfig $KubeconfigFile --namespace $Namespace

function DeGZip-File {
    param (
        $infile,
        $outfile = ($infile -replace '\.gz$', '')
    )

    $input = [System.IO.File]::OpenRead($inFile)
    $output = [System.IO.File]::Create($outFile)
    $gzipStream = [System.IO.Compression.GzipStream]::new($input, [System.IO.Compression.CompressionMode]::Decompress)

    $buffer = [byte[]]::new(1024)
    while ($true) {
        $read = $gzipStream.Read($buffer, 0, 1024)
        if ($read -le 0) { break }
        $output.Write($buffer, 0, $read)
    }

    $gzipStream.Close()
    $output.Close()
    $input.Close()
}

Write-Host "Desempaquetando archivo de volcado"

DeGZip-File (Join-Path $OutputDirectory $archiveFileName) (Join-Path $OutputDirectory $fileName)

Guarda el script como un archivo MemoryDump.ps1 y disfruta creando volcados de memoria con esta única línea:

./MemoryDump.ps1 -PodName 'NOMBRE_DE_TU_POD' -Namespace 'TU_ESPACIO_DE_NOMBRES' -KubeconfigFile './TU_KUBECONFIG.yaml'

Conclusión

Recopilar volcados de memoria de aplicaciones .NET en ejecución en Kubernetes puede proporcionar información valiosa sobre su estado durante momentos críticos.

Si te armas con la información de los volcados de memoria, podrás solucionar y abordar de manera más efectiva problemas dentro de tus aplicaciones .NET.

Recuerda que el análisis de volcados de memoria requiere familiaridad con herramientas y técnicas de depuración, pero es una habilidad que puede mejorar significativamente tu capacidad para mantener y mejorar el rendimiento y la confiabilidad de tus aplicaciones.