Aspectos

El comando locale se divide en varias categorías que cubren diferentes aspectos de la localización entre los que se encuentra:

• LANG: Define el locale general del sistema. Es el valor principal que afecta a todas las demás configuraciones si no se especifican individualmente.
• LC_CTYPE: Define el comportamiento de la clasificación de caracteres y cómo se manejan los caracteres especiales. Es crucial para determinar cómo se interpretan las letras mayúsculas/minúsculas, y la codificación de caracteres como UTF-8.
• LC_NUMERIC: Controla el formato de los números, como la forma en que se muestran los separadores decimales y de miles.
• LC_TIME: Afecta cómo se muestran las fechas y las horas, incluyendo el formato de la hora (24 horas vs. 12 horas), la presentación de los días de la semana, meses y demás.
• LC_COLLATE: Define las reglas de ordenación y comparación de cadenas de texto, es decir, cómo se ordenan los datos en listas alfabéticas.
• LC_MONETARY: Define el formato en el que se muestra el dinero, incluyendo el símbolo de la moneda, el separador decimal, y la ubicación del símbolo de moneda respecto al valor numérico.
• LC_MESSAGES: Afecta el idioma en el que se muestran los mensajes del sistema y de las aplicaciones, como los mensajes de error.
• LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT, LC_IDENTIFICATION: Estas categorías se encargan de detalles más específicos, como el tamaño de papel predeterminado, la representación de nombres y direcciones, los formatos de números de teléfono, las unidades de medida (métrico o imperial), y otros datos de identificación.
• LC_ALL: Es un valor especial que anula todas las configuraciones anteriores. Si se establece LC_ALL, este tiene prioridad sobre las demás variables LC_* y LANG.

Configuración

Regularmente se hace mediante una terminal con los comandos que se describe a continuación

1. Hay que instalar el paquete, para ello se realiza con la siguiente instrucción: sudo dnf install glibc-langpack-es. Con esto se brinda el soporte para UTF-8.
2. Ahora hay que crear el locale, eso se hace con la ayuda del comando sudo nano /etc/locale.conf. Dentro de este archivo debe de llevar la siguientes lineas:
   • LANG=es_ES.UTF-8
   • LC_ALL=es_ES.UTF-8
3. Luego de guardar los cambios en el fichero locale.conf, es momento de establecer el tipo de configuración, para ello se ejecuta el comando: sudo localectl set-locale LANG=es_ES.UTF-8.
4. No olvidar verificar la configuración, para ello se ejecuta el siguiente comando: localectl list-locales | grep es_ES.UTF-8.
5. Reinicie el sistema operativo con el comando sudo reboot
6. Compruebe la configuración con el comando locale.

Errores

Los errores que suelen aparecer o indicar que no se tiene configurado o instalado el locale suelen ser los siguiente:

• Failed to issue method call: Locale es_ES.UTF-8 not installed, refusing.
• locale: Cannot set LC_CTYPE to default locale: No such file or directory
• locale: Cannot set LC_MESSAGES to default locale: No such file or directory
• locale: Cannot set LC_ALL to default locale: No such file or directory

Aprendizaje

Regularmente cuando te brindan los servidores de desarrollo o producción no suele preocuparse uno por las configuraciones lingüísticas debido a que ya va pre-configurado. Pese a que a que se utilicen diversas técnicas que te permite mostrar la acentuación en español de manera adecuada. Como hacer uso de etiquetas meta en el html o de funciones que te permite tener ese tipo de cuidado del lado del lenguaje de programación.

La entrada locale se publicó primero en Frexus.

Un día toca interactuar con alma linux para hacer las configuraciones adecuadas y montar un servidor en producción para ello se hace uso de los siguientes comandos:

Instalación LAMP en Alma Linux

A continuación se muestra los pasos necesarios para realizar una instalación del Servidor apache, el gestor de base de datos Maria db y el lenguaje de programación php.

1. Actualizar el repositorio, se realiza con el siguiente comando: sudo dnf update
2. Instalar el servidor web apache, para ello se usa el siguiente comando: sudo dnf install httpd
3. Inicializar el servidor, para ello el comando: sudo systemctl start httpd
4. Añadirlo para que inicie durante el arranque: sudo systemctl enable httpd.service
5. Instalar el gestor de base de datos, se realiza usando el comando: sudo dnf intall mariadb-server mariadb
6. Iniciar el servicio, se hace con el comando: sudo systemctl start mariadb
7. Añadirlo para que inicie durante el arranque: sudo systemctl enable mariadb
8. Configurar mariadb, con el comando: sudo mysql_secure_installation
9. Instalar php, con el comando: sudo dnf module install php:8.1. :8.1 indica la versión de php que se instalara.
10. Reiniciar el servicio httpd para la integración de php: sudo systemctl restart httpd.service
11. Instalar modulos particulares de php: sudo dnf install module php-curl php-zip php-opcache php-mysqlnd en este caso se instala el modulo curl, zip, cache y conector con mysql de php

Instalación de phpmyadmin

Para instalar phpmyadmin en alma linux 9 se puede hacer uso de los siguientes pasos:

1. Descargar el paquete phpmyadmin desde la pagina oficial, esto brindará tener la última versión y habrá que estar actualizandola cuando se requieera, para esto se debe hacer uso del comando: sudo wget https://files.phpmyadmin.net/phpMyAdmin/5.2.1/phpMyAdmin-5.2.1-all-languages.zip
2. Ahora hacer el unzip, para ello hay que instalar el zip con el comando: sudo dnf install zip luego aplicar el sudo unzip al archivo que se descargo: sudo unzip phpMyAdmin-5.2.1-all-languages.zip
3. Se cambia el nombre de la carpeta, con el comando: sudo mv phpMyAdmin-5.2.1-all-languages phpmyadmin

Servicio de FTP

Ahora hay que instalar un servidor ftp en alma linux 9 para que permita subir los ficheros y demás cosas que el servidor debe de tener para hacer esto hay que hacer los siguientes pasos:

1. Primero hay que instalar el servidor ftp para ello se hace uso del comando: sudo dnf install vsftpd.
2. Luego de habilitar el servicio cuando arranque el servidor, con el comando sudo systemctl enabe vsftpd.
3. Posteriormente hay que iniciar el servicio: sudo systemctl start vsftpd.service.
4. Y por último modificar el archivo de configuración de vsftpd que se encuentra en la siguiente ruta: /etc/vsftpd/vsftpd.conf las lineas que se deben de cambiar son: anonymous_enable=NO, cambiarlo a YES, debe de quedar anonymous_enable=YES. local_enable=YES, write_enable=YES, y descomentar la linea anon_upload_enable=YES. Estas modificaciones permitirá que cualquier usuario registrado en el sistema alma linux 9 pueda acceder a escribir, y subir fichero en el servidor. Para acceder a estas modificaciones se puede hacer con el editor nano se instala con el siguiente comando: sudo dnf install nano y para acceder a modificar el fichero se hace con el comando: sudo nano /etc/vsftpd/vsftpd.conf
   • Para subir los archivos ya con filezilla se conecta con la dirección ip, con el usuario y contraseña con el que se autentica en el sistema alma linux 9.

Y con estos pasos se tendrá un servidor ftp, web y gestor de base de datos listo para trabajar en Alma Linux con php y a subir ficheros con filezilla.

La entrada Alma Linux se publicó primero en Frexus.

El manejo de archivo son esenciales para manipular datos almacenados en dispositivos de almacenamiento. Se encuentra las siguientes características:

• Tipos de Archivos: En el shell, los archivos pueden ser de diferentes tipos, como archivos de texto, archivos binarios, directorios, enlaces simbólicos, entre otros. Cada tipo de archivo tiene su propósito y puede manipularse mediante comandos específicos del shell.
• Extensiones y Nombres: Aunque en sistemas basados en Unix/Linux no es obligatorio, es común utilizar extensiones de archivo para indicar el tipo de contenido. Por ejemplo, .txt para archivos de texto.
• Ubicación y Rutas: Los archivos pueden estar ubicados en diferentes directorios. La especificación de rutas (absolutas o relativas) es esencial para trabajar con archivos en el shell.

Operaciones Básicas con Archivos

Creación de Archivos: El comando touch se utiliza para crear archivos vacíos. Por ejemplo:

touch mi_archivo.txt

Visualización de Contenido: Para ver el contenido de un archivo, puedes usar comandos como cat, more, o less. Por ejemplo:

cat mi_archivo.txt

Edición de Archivos: Puedes editar archivos directamente desde el shell utilizando editores de texto como nano, vim, o emacs. Por ejemplo:

nano mi_archivo.txt

Eliminación de Archivos: El comando rm se utiliza para eliminar archivos. Por ejemplo:

rm mi_archivo.txt

Entrada y Salida Estándar

Redirección de la Entrada y Salida: Los operadores < y > permiten redirigir la entrada y salida estándar hacia o desde archivos, respectivamente. Por ejemplo:

comando < entrada.txt > salida.txt

Concatenación de Archivos: Puedes concatenar el contenido de varios archivos usando el operador >>. Por ejemplo:

cat archivo1.txt archivo2.txt >> resultado.txt

Tuberías (Pipes): El símbolo | se utiliza para enviar la salida de un comando como entrada a otro. Por ejemplo:

comando1 | comando2

Permisos y Propietarios

En sistemas basados en Unix/Linux, cada archivo y directorio tiene asociados permisos y un propietario. Estos atributos determinan quién puede acceder, modificar o ejecutar el archivo. Aquí tienes información detallada sobre permisos y propietarios

Permisos:

Tipos de Permisos: Los permisos se dividen en tres categorías: lectura (r), escritura (w), y ejecución (x). Cada categoría se aplica a tres entidades diferentes: el propietario del archivo, el grupo al que pertenece el archivo, y otros usuarios.

Asignación de Permisos: Puedes asignar permisos usando el comando chmod. Por ejemplo, para otorgar permisos de lectura y escritura al propietario de un archivo, puedes usar:

chmod u+rw archivo.txt

Notación Numérica: Los permisos también pueden expresarse en notación numérica. Por ejemplo, el permiso de lectura es 4, el de escritura es 2, y el de ejecución es 1. Puedes sumar estos valores para asignar permisos. Por ejemplo, para dar permisos de lectura y escritura al propietario, puedes usar:

chmod 600 archivo.txt

Cambio de Permisos: El comando chmod te permite cambiar los permisos de un archivo. Por ejemplo:

chmod +x script.sh

Propietarios

Propietario del Archivo: Cada archivo tiene un propietario principal que tiene control total sobre el archivo. Puedes cambiar el propietario utilizando el comando chown. Por ejemplo:

chown nuevo_propietario archivo.txt

Grupo Asociado: Además del propietario, cada archivo está asociado a un grupo. Puedes cambiar el grupo utilizando chown. Por ejemplo:

chown :nuevo_grupo archivo.txt

Herencia de Permisos: El grupo hereda algunos de los permisos del propietario. Esto significa que si el propietario tiene permisos de escritura, el grupo también los tendrá.

Cambio de Propietario: El comando chown te permite cambiar el propietario de un archivo. Por ejemplo:

chown nuevo_propietario archivo.txt

Combinación de Permisos y Propietarios:

• Combinación de Permisos y Propietarios: La combinación efectiva de permisos y propietarios determina quién puede hacer qué con un archivo. Por ejemplo, un archivo con permisos 644 (rw-r–r–) significa que el propietario tiene lectura y escritura, mientras que el grupo y otros solo tienen permisos de lectura.
• Ejemplo Práctico: Para dar permisos de lectura y escritura al propietario, y solo permisos de lectura a otros, puedes usar:

chmod 644 archivo.txt

Uso de Grupos: Puedes asignar archivos a grupos específicos para que varios usuarios tengan acceso. Esto es útil para proyectos colaborativos.

Estos son solo algunos ejemplos y conceptos básicos relacionados con archivos en el contexto de la programación en el shell y la manipulación de la entrada y salida estándar. La habilidad para trabajar eficientemente con archivos es esencial para cualquier tarea de programación y administración de sistemas en un entorno de shell.

La entrada Archivos se publicó primero en Frexus.

En la programación de shell, los argumentos son valores que se proporcionan a un script o programa cuando se ejecuta. Estos valores permiten que el script o programa actúe de manera dinámica y adaptable a diferentes situaciones.

Cómo se pasan los argumentos:

• Se pasan después del nombre del script o comando cuando se ejecuta en la línea de comandos.
• Por ejemplo: ./mi_script.sh arg1 arg2 arg3

Variables especiales:

• En la mayoría de las shells, puedes acceder a los argumentos dentro del script mediante variables especiales:
  • $0: Nombre del script o comando.
  • $1, $2, $3, …: Representan el primer, segundo, tercer argumento, y así sucesivamente.

Número total de argumentos:

• Puedes obtener el número total de argumentos usando $#. Por ejemplo, echo "Número total de argumentos: $#".

Todos los argumentos como una cadena:

• $* o $@ representan todos los argumentos como una única cadena. La diferencia principal es cómo manejan los espacios en blanco.
  • $*: Trata todos los argumentos como una sola palabra.
  • $@: Trata cada argumento como una palabra separada.

Ejemplo práctico:

• Supongamos que tienes un script llamado mi_script.sh:

#!/bin/bash

echo "Nombre del script: $0"
echo "Primer argumento: $1"
echo "Segundo argumento: $2"
echo "Todos los argumentos: $*"
echo "Número total de argumentos: $#"

Al ejecutar ./mi_script.sh arg1 arg2, obtendrías la salida correspondiente.

Estos conceptos te permiten escribir scripts de shell más versátiles y adaptables al aceptar diferentes entradas durante la ejecución.

La entrada Argumentos en la programación se publicó primero en Frexus.

La programación de entrada y salida estándar en el shell se refiere a la manipulación de los flujos de entrada y salida de datos en un programa de shell. En la mayoría de los sistemas operativos tipo Unix/Linux, los comandos en la shell interactúan con el usuario y con otros programas a través de tres flujos de datos estándar:

1. Entrada estándar (STDIN): Este es el flujo de datos que lleva la entrada al programa. Normalmente, en la shell, la entrada estándar es el teclado. Los programas leen datos desde la entrada estándar para procesarlos.
2. Salida estándar (STDOUT): Este es el flujo de datos que lleva la salida normal del programa. Por lo general, en la shell, la salida estándar es la pantalla. Los programas imprimen resultados y mensajes en la salida estándar.
3. Error estándar (STDERR): Este es el flujo de datos que lleva mensajes de error. Así como la salida estándar, en la shell, la salida de error suele ir a la pantalla. Los programas imprimen mensajes de error en el error estándar para separarlos de la salida normal y permitir un manejo más efectivo.

En la programación de shell, se puede redirigir estos flujos de datos para realizar tareas específicas. Algunos conceptos clave incluyen:

• Redirección: Cambiar el destino de un flujo de datos. Se puede redirigir la salida de un comando a un archivo, por ejemplo.
• Pipes (Tuberías): Conectar la salida de un comando a la entrada de otro. Esto permite que los comandos trabajen en conjunto, y es fundamental para la filosofía de “hacer una cosa y hacerla bien” en Unix.
• Entrada/Salida en Modo Binario: Aunque los flujos estándar se tratan comúnmente como texto, también se pueden manejar en modo binario para datos no textuales.

Finalmente se puede decir que la programación de entrada y salida estándar en el shell implica el manejo efectivo de cómo los programas interactúan con los datos de entrada, producen resultados y manejan mensajes de error.

La entrada i/o estándar en el shell se publicó primero en Frexus.

El shell es un programa informático que proporciona una interfaz de usuario para acceder a los servicios del sistema operativo. Actúa como una interfaz entre el usuario y el núcleo del sistema operativo, permitiendo la ejecución de comandos y la manipulación de archivos.

En un sistema operativo basado en Unix o Linux, el shell es una parte esencial. Aquí hay algunas características clave:

1. Interfaz de línea de comandos (CLI): El shell proporciona una interfaz de texto donde el usuario puede ingresar comandos y recibir resultados.
2. Interpretación de Comandos: El shell interpreta los comandos escritos por el usuario y los traduce en acciones que el sistema operativo puede llevar a cabo. Puede ejecutar programas, manipular archivos y realizar otras tareas del sistema.
3. Redirección y Piping: Permite la redirección de la entrada y salida estándar, lo que significa que puedes redirigir la salida de un comando a un archivo o usarla como entrada para otro comando (piping).
4. Automatización: Los scripts del shell permiten la automatización de tareas al escribir una secuencia de comandos para ejecutarse en secuencia.
5. Variables y Entorno: Puedes definir variables y entorno que afectan el comportamiento de los comandos y programas.

En sistemas Unix y Linux, hay varios shells disponibles, como Bash (Bourne Again SHell), Zsh (Z Shell), y Fish (Friendly Interactive SHell), entre otros. Cada uno tiene sus características y comandos específicos, pero todos comparten el propósito fundamental de proporcionar una interfaz para interactuar con el sistema operativo a través de comandos.

Actividad.

1. Crea un directorio con el nombre de Programacion_Unix
2. Dentro de el crea un directorio con tu nombre.
3. Dentro del directorio con tu nombre, crea un archivo con el nombre iudy.txt (usa nano para crearlo)
4. Mueve el archivo iudy.txt al directorio Programación_Unix
5. Crea una copia del archivo iudy.txt y asignale el nombre de Usa_shell,txt.
6. Edita el documento Usa_shell.txt y coloca los comando que has usado hasta el momento.

La entrada Usando el shell se publicó primero en Frexus.

Una empresa de tamaño mediano decide migrar su infraestructura informática a un entorno basado en el sistema operativo Linux. La empresa busca mejorar la seguridad, reducir costos y aumentar la eficiencia operativa.

Desafío: La empresa opera actualmente en un entorno heterogéneo con sistemas operativos propietarios y enfrenta desafíos relacionados con la seguridad, el rendimiento y los costos de licencia.

Solución: Implementación de Linux en Toda la Infraestructura

1: Evaluación de Necesidades:

• Se realiza una evaluación exhaustiva de los requisitos y las necesidades de la empresa.
• Se identifican las áreas clave donde Linux puede ofrecer mejoras significativas.

2: Diseño de la Arquitectura:

• Se diseña una arquitectura de sistemas que incluye servidores, estaciones de trabajo y dispositivos de red basados en Linux.
• Se seleccionan distribuciones de Linux adecuadas para cada caso de uso.

3: Migración Gradual:

• Se implementa un plan de migración gradual para minimizar la interrupción de las operaciones comerciales.
• Se proporciona formación a los empleados para facilitar la transición.

4: Personalización y Desarrollo de Herramientas:

• Se desarrollan herramientas personalizadas para satisfacer las necesidades específicas de la empresa.
• Se integran soluciones de código abierto para maximizar la eficiencia.

5: Monitorización y Optimización Continuas:

• Se implementa un sistema de monitorización constante para garantizar el rendimiento y la seguridad.
• Se optimizan y ajustan continuamente los sistemas según las necesidades cambiantes de la empresa.

Resultados:

• Se logra una mejora significativa en la seguridad de la infraestructura.
• La empresa experimenta ahorros sustanciales en costos de licencias y hardware.
• La eficiencia operativa aumenta con la estandarización en entornos Linux.

Lecciones Aprendidas:

• La planificación cuidadosa y la migración gradual son clave para el éxito.
• La personalización y el desarrollo de herramientas pueden adaptar Linux a las necesidades específicas de la empresa.
• La monitorización constante y la optimización garantizan un rendimiento óptimo a largo plazo.

La entrada Linux en un Entorno Empresarial se publicó primero en Frexus.

C# como lenguaje de programación, mssqlserver como gestor de base de datos y fedora como sistema operativo donde permita crear una aplicación sencilla. No era algo rentable hasta ahora. Claro que con una versión de mssqlserver en docker es posible.

Una vez que ya se tiene instalado el contenedor con mssqlserver, ya si instalo .netcore. No queda otra cosa que probar la conexión desde c# un clásico, insertar, actualizar, eliminar y mostrar el contenido de la tabla afectada.

Para el ejercicio se creo una tabla con el nombre TestDB, el cual contiene una tabla llamada inventario, donde tendrá tres campos, un identificador (ID) de tipo entero, un nombre de tipo nvarchar con una longitud de 50 y para terminar un campo cantidad de tipo entero. El código usado para crear la base de datos y la tabla fue el siguiente:

Todos los archivos los encuentras en el github

Create datababase TestDB;
go
Use TestDB;
go
Create table inventario (id int, nombre nvarchar(50), cantidad int);
go

Librerías

Las librerías que se usaron para la creación de este ejercicio fueron

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

Funciones

Se crearon cuatro funciones la primera que se creo fue la de mostrar los datos de la tabla, una de insertar un registro, otra para actualizar un registro y finalmente una para eliminar el registro de la tabla. Es con fines didácticos y probar el comportamiento de .net core y mssql server en una distribución linux.

Función Mostrar datos

Esta función permitió mostrar el contenido de la tabla inventario después de cada acción que se realizo (inserción, actualización y eliminación). Y le pide al usuario que pulse una tecla para que continue con el proceso.

void MuestraDatos()
                            {
                                SqlDataAdapter adaptador = new SqlDataAdapter("Select * from inventario",connection);
                                DataTable dt = new DataTable();
                                adaptador.Fill(dt);
                                Console.WriteLine(">>> Mostrando contenido de la tabla inventario <<<");
                                Console.WriteLine("ID    -|- Nombre          -|- Cantidad");
                                Console.WriteLine("--------------------------------------");
                                foreach (DataRow item in dt.Rows)
                                {
                                    Console.WriteLine(item["id"].ToString() + "     -|- "+item["nombre"].ToString() + "        -|- " + item["cantidad"]);
                                }
                                Console.WriteLine(">>> Fin del contenido de la tabla inventario <<< ");
                                Console.WriteLine("Pulse una tecla para continuar");
                                Console.ReadKey(true);
                            }

Función Registrar datos

Esta función permitió agregar un registro a la tabla inventario y manda a llamar a la función MostrarDatos(), para visualizar el registro que se agrego. Vea imagen 1

void RegistraDatos()
                            {
                                String sql = "";
                                Console.WriteLine("Preparando insercición de registros en inventario");
                                sql="Use TestDB; Insert Into inventario values (1,'Manzanas',300);";
                                SqlCommand command = new SqlCommand(sql,connection);
                                command.ExecuteNonQuery();
                                Console.WriteLine("Registro insertado con éxito");
                                MuestraDatos();
                            }

Función Actualizar datos

Esta función permitió agregar un registro a la tabla inventario y manda a llamar a la función MostrarDatos(), para visualizar la afectación a la fila realizada. Vea imagen 2

void ActualizaDatos()
                            {
                                String sql = "";
                                Console.WriteLine("Cambiar el nombre Manzanas por Sandias");
                                sql="Use TestDB; Update inventario set nombre = 'Sandias' where id=1";
                                SqlCommand commandA = new SqlCommand(sql,connection);
                                commandA.ExecuteNonQuery();
                                Console.WriteLine("Registro Actualizado con éxito");
                                MuestraDatos();
                            }

Función Eliminar datos

Finalmente esta función, vacía el registro de la tabla inventario y manda a llamar a la función MostrarDatos(), para que se visualice la eliminación. Vea imagen 3

void EliminaDatos()
                            {
                                String sql = "";
                                Console.WriteLine("Vaciar la tabla inventario");
                                sql="Use TestDB; Delete inventario";
                                SqlCommand commandE = new SqlCommand(sql,connection);
                                commandE.ExecuteNonQuery();
                                Console.WriteLine("Tabla inventario vaciada con éxito");
                                MuestraDatos();
                            }

Código completo usado

Tenía mas de un par de décadas que no tocaba c# y mssql. Parte del código se consolido con la documentación que ofrece Microsoft para la comprobación de conexión con mssql en el docker.

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SqlServerColumnstoreSample
{
    class Program 
    {
        static void Main(string[] args)
        {
            Console.WriteLine(" Conectando con sqlserver desde c# ");
            SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder();
            builder.DataSource = "localhost";
            builder.UserID = "sa";
            builder.Password = "Nemesis28;";
            builder.InitialCatalog = "master";
            Console.WriteLine("Conectando con sqlserver");
            using (SqlConnection connection = new SqlConnection(builder.ConnectionString))
            {
                            void MuestraDatos()
                            {
                                SqlDataAdapter adaptador = new SqlDataAdapter("Select * from inventario",connection);
                                DataTable dt = new DataTable();
                                adaptador.Fill(dt);
                                Console.WriteLine(">>> Mostrando contenido de la tabla inventario <<<");
                                Console.WriteLine("ID    -|- Nombre          -|- Cantidad");
                                Console.WriteLine("--------------------------------------");
                                foreach (DataRow item in dt.Rows)
                                {
                                    Console.WriteLine(item["id"].ToString() + "     -|- "+item["nombre"].ToString() + "        -|- " + item["cantidad"]);
                                }
                                Console.WriteLine(">>> Fin del contenido de la tabla inventario <<< ");
                                Console.WriteLine("Pulse una tecla para continuar");
                                Console.ReadKey(true);
                            }
                            void RegistraDatos()
                            {
                                String sql = "";
                                Console.WriteLine("Preparando insercición de registros en inventario");
                                sql="Use TestDB; Insert Into inventario values (1,'Manzanas',300);";
                                SqlCommand command = new SqlCommand(sql,connection);
                                command.ExecuteNonQuery();
                                Console.WriteLine("Registro insertado con éxito");
                                MuestraDatos();
                            }
                            void ActualizaDatos()
                            {
                                String sql = "";
                                Console.WriteLine("Cambiar el nombre Manzanas por Sandias");
                                sql="Use TestDB; Update inventario set nombre = 'Sandias' where id=1";
                                SqlCommand commandA = new SqlCommand(sql,connection);
                                commandA.ExecuteNonQuery();
                                Console.WriteLine("Registro Actualizado con éxito");
                                MuestraDatos();
                            }
                            void EliminaDatos()
                            {
                                String sql = "";
                                Console.WriteLine("Vaciar la tabla inventario");
                                sql="Use TestDB; Delete inventario";
                                SqlCommand commandE = new SqlCommand(sql,connection);
                                commandE.ExecuteNonQuery();
                                Console.WriteLine("Tabla inventario vaciada con éxito");
                                MuestraDatos();
                            }
                connection.Open();
                Console.WriteLine("Conexión establecida con exito");
                RegistraDatos();
                ActualizaDatos();
                EliminaDatos();                
            }
        }
    }
}

Creando la Aplicación

Me genero cierta sorpresa que se tenga que usar el commando dotnet (después de instalarlo el .netcore) muy al estilo de java, rust, python, go e incluso ruby. En el sentido que para crear la aplicación se tiene que ejecutar el comando:

dotnet new console -o NombreAplicacion

Lo que genera una carpeta donde viene el xml, y main del programa ya solo se tiene que editar el fichero Program.cs y después de eso ejecutar el comando:

dotnet run

Claro que se tiene que estar dentro de la carpeta que se creo con el comando anterior para que se ejecute, cada modificación que se realice al fichero Program.cs, se debe de ejecutar el comando dotnet.cs

Finales

Es satisfactorio poder ahora crear aplicaciones en csharp con conexión en mssql, sobre todo que ya hay soporte para distribuciones linux, se espera que pronto salga las versiones arm para que puedan ser ejecutadas y creadas en las nuevas Mac.

La aplicación de consola es muy sencilla, pero permitió ver la facilidad de conexión, quizá en otra entrada se dedique una con interfaz gráfica. Recuerdo que antes solo se usaba una versión de mono para poder crear aplicaciones en csharp, pero al quererlas ejecutar en windows era un rollo. Solo faltaría ver si eso se ha quitado o no.

No se debe de olvidar que el servicio de docker debe de estar en ejecución para que la conexión pueda generarse.

La entrada C# y MS SQL Server en el contenedor se publicó primero en Frexus.

Se debe de recordar que por aquellos tiempos crear una aplicación de escritorio se tenía que llevar la versión del .net en el que se creo la aplicación, y si por alguna circunstancia extraordinaria se actualizaba la aplicación dejaba de funcionar.

Es un sentido muy extraño que después de tantos tiempo Microsoft permita que sus tecnologías puedan ser instaladas en sistemas operativos libres, por lo que si se quiere instalar el sdk para crear aplicaciones solo hay que ejecutar el siguiente comando, al menos en un entorno de la familia red hat.

dnf install dotnet-sdk-6.

si se estuviera en las familias de debian solo se tendría que cambar el dnf por apt.

La entrada Net core en una distribución linux (fedora 35) se publicó primero en Frexus.