Extender un volumen LVM en Linux

Para este este ejemplo nuestro objetivo será extender las particiones /tmp y /var, todos los comandos a continuación deben ser ejecutados como root o sudo.

# df -Thl

Primero añadimos un nuevo disco duro virtual a la máquina virtual, para este caso uno con 1 GB de capacidad. Cabe añadir que también podemos extender nuestro LVM si disponemos de espacio disponible en un disco ya existente, para este caso deberíamos simplemente crear una nueva partición en el disco existente con el espacio disponible.

Encendemos la máquina virtual y revisamos la información sobre todos los dispositivos de bloque disponibles. Como podremos observar disponemos de tres discos duros sda, sdb cuyas particiones son parte del LVM y sdc que agregamos recientemente al sistema.

# lsblk -fm

También podemos ver el detalle de los dispositivos físicos y observaremos que sdc no contiene particiones.

# fdisk -l

# fdisk –l /dev/sdc

Lo primero que debemos hacer es crear nuestra nueva partición con el disco nuevo. Como había mencionado anteriormente podemos realizar también esta operación si disponemos de espacio en un disco ya existente por ejemplo sda y sdb. Como en nuestro ejemplo disponemos de espacio en sdc crearemosla nueva partición aquí y la añadiremos posteriormente a nuestro LVM. Podemos también crear dos o más particiones y añadirlas, en este caso solo crearemos una.

# fdisk /dev/sdc

• n para  nuevo
• p partición primaria
• t tipo (por defecto se selecciona la primera partición)
• 8e Partcion LVM Linux
• El resto de opciones podemos aplicar ENTER para dejarlas por defecto
• W para escribir los cambios

Si revisamos de nuevo veremos que disponemos de una nueva partición /dev/sdc1 en nuestro disco /dev/sdc.

Lo siguiente es crear un volumen “físico” (si, se trata de una máquina virtual pero recordemos que estamos emulando en realidad lo que sería un disco físico). Para ver cuantos volúmenes físicos tenemos ejecutamos

# pvdisplay 

Para crear el volumen físico ejecutamos los siguiente en nuestra partición recientemente creada /dev/sdc1

# pvcreate /dev/sdc1

En nuestro LVM está constituido por un grupo de volúmenes denominado vg_sys

# vgdisplay

Extendemos nuestro grupo de volúmenes con nuestra nueva partición /dev/sdc1.

# vgextend vg_sys /dev/sdc1

Y veremos el espacio disponible que ahora es de 1024 MB correspondiente a la partición añadida.

Ahora vamos a extender nuestros volúmenes físicos, para examinarlos ejecutamos

# lvdisplay

También podemos ver más detalles como el tamaño y el estado de cada volumen lógico:

# lvs
# lvscan

Para nuestro ejemplo nuestro objetivo es extender los volúmenes lógicos /dev/vg_sys/lv_tmp y /dev/vg_sys/lv_var.  Para ampliar 500 MB   a tmp ejecutamos:

# lvextend -L +500M /dev/vg_sys/lv_tmp

• M para MB
• G para GB

Para ampliar el resto de espacio disponible a var ejecutamos:

# lvextend -l +100%FREE /dev/vg_sys/lv_var

Pero aun no vemos reflejado el espacio añadido en nuestro sistema de ficheros

Para poder ver el espacio extendido debemos redimensionar el sistema de ficheros tambien.

# resize2fs /dev/vg_sys/lv_tmp
# resize2fs /dev/vg_sys/lv_var

• resize2fs para ext4
• xfs_growfs para xfs

Resumen de comandos utilizados

# df -Thl
# lsblk -fm
# fdisk -l
# fdisk –l /dev/sdc
# fdisk /dev/sdc
•	n para  nuevo
•	p partición primaria
•	t tipo (por defecto se selecciona la primera partición)
•	8e Partcion LVM Linux
•	El resto de opciones podemos aplicar ENTER para dejarlas por defecto
•	W para escribir los cambios

# pvdisplay 
# pvcreate /dev/sdc1
# vgdisplay
# vgextend vg_sys /dev/sdc1
# lvdisplay
# lvs
# lvscan
# lvextend -L +500M /dev/vg_sys/lv_tmp
•	M para MB
•	G para GB
# lvextend -l +100%FREE /dev/vg_sys/lv_var
# resize2fs /dev/vg_sys/lv_tmp
# resize2fs /dev/vg_sys/lv_var
•	resize2fs para ext4
•	xfs_growfs para xfs

Referencias

http://apuntes.ucr.ac.cr/index.php/Aumentar_capacidad_de_un_disco_en_Logical_Volume_Management_(LVM)
https://www.zeppelinux.es/extender-volumenes-lvm-logical-volume-manager/
https://cduser.com/como-extender-un-volumen-lvm-linux/
https://www.youtube.com/watch?v=KW1ScgdCIfs

Configurando un Cluster DRBD con CentOS7

DRBD (Distributed Replicated Block Device) es una herramienta open source (GNU General Public License v2) que nos permite realizar la sincronizacion de datos entre servidores mediante una red de alta velocidad, brindando de esta manera redundancia entre dispositivos de almacenamiento. Esto no permitirá a su vez crear una solución de alta disponibilidad (HA) y tolerancia a fallos (FT).

REQUERIMIENTOS

Para fines de este tutorial tenemos 2 servidores Centos 7 previamente instalados y actualizados. Así mismo ambos servidores disponen de dos tarjetas de red una para la LAN y otra dedicada para sincronizar mediante DRBD de acuerdo al siguiente diagrama:

Tenga listo un dispositivo adicional particionado (en mi caso /dev/sdb1) previamente en el servidor (no debe estar montado). Posteriormente usaremos el mismo para crear el dispositivo drbd (en mi caso /dev/drdb1).

Es importante que ambos servidores tengan las mismas características en cuanto a software y hardware. De igual manera los dispositivos de disco que serán replicados deben ser idénticos en cuanto al volumen.

Asegure el correcto trafico entre las interfaces red, agregue una ruta especifica para la red LAN para evitar problemas (e mi caso: 10.0.0.0/8 via 10.1.30.1 dev ens33).

INSTALACION

(Ejecute los siguientes pasos en el «nodo 1» y «nodo 2»)

Añadir el repositorio «ELRepo» para RHEL-7,  SL-7 o CentOS-7

# rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org

— Si falla por proxy , asegura tener bien configurado tu /etc/environment 😉

Ver los paquetes disponibles (deberías poder visualizar los correspondientes a DRBD)

# yum list | grep drbd

Instalar DRBD

# yum -y install drbd84-utils kmod-drbd84

Verificar las versiones instaladas

# yum list installed | grep drbd

CONFIGURACION

(Ejecute los siguientes pasos en el «nodo 1» solamente)

Cargar los módulos DRBD manualmente.

# modprobe drbd

Verificar que los modulos DRBD esten cargados correctamente

# lsmod | grep drbd

Definir el nombre de host de cada nodo

# hostnamectl set-hostname nodo1 (en nodo1)
# hostnamectl set-hostname nodo2 (en nodo2)

Asegurar la comunicacion entre ambos nodos :

# cat /etc/hosts
10.1.30.176 nodo1
10.1.30.177 nodo2

Comprobar el nombre de host

# hostname
# uname -a

Ingresar a la configuracion del demonio de drbd

# cd /etc/drbd.d/

Crear un archivo opt_disk.res con el mismo contenido «en cada nodo»

# nano opt_disk.res

Puntos clave :

– Configurar la replica con la partición, no con el disco
– device /dev/drdb1; es el nombre del dispositivo drbd creado.
– disk /dev/sdb1; es la partición que debe estar instalada previamente en el servidor (no debe estar montado)
– Para address use el IP interno de comunicación entre nodos Ethernet y NO 10.x.x.x IP
– Los nombres de la sección «on» de este archivo deben coincidir con los nombres de host de cada nodo

Ejemplo:

resource opt_disk
{
 protocol C;
 device /dev/drbd1;
 disk /dev/sdb1;
 meta-disk internal;

 startup {
  wfc-timeout 30;
  outdated-wfc-timeout 20;
  degr-wfc-timeout 30;
 }

 net {
  cram-hmac-alg sha1;
  shared-secret sync_disk;
 }

 syncer {
  rate 35M;
  verify-alg sha1;
 }

 on nodo1 {
  address 172.0.0.201:7788;
 }
 on nodo2 {
  address 172.0.0.202:7788;
 }
}

Inicializamos metadatos de almacenamiento, ejecutamos en ambos nodos uno después de otro.

# drbdadm create-md opt_disk

NOTA
Los discos no deben estar montados ni con el sistema de archivos creado
Debe tener lista una partición ejemplo: /dev/sdb1

Inicie y habilite el servicio DRBD

# systemctl start drbd
# systemctl enable drbd

(Esto puede tardar unos minutos, verificque su firewalld 😉 )

Inicie el dispositivo ***

# drbdadm up opt_disk

(Esto puede tardar unos minutos,  verifique firewalld 😉 )

Verifique la sincronizacion de datos

# cat /proc/drbd

«Realice todos los pasos explicados hasta aqui en el «nodo 2″ y verifique /proc/drbd en ambos nodos.»

La primera vez ambos nodos estaran en Secondary/Secondary – Inconsistent/Inconsistent, esto por que aun no estamos sincronizando datos.
Si algun nodo aparece con estado desconocido Secondary/Uknow verifique la comunicacion entre ambos nodos (firewalld 😉  y habilite los puertos especificados en la configuracion drbd.

Agregar esta regla
Iptables:

# -A INPUT -p tcp -m state --state NEW -m tcp --dport 7788 -j ACCEPT

Firewalld

# firewall-cmd --add-port=7788/tcp --permanent
# firewall-cmd --reload

Conviertiendo uno de los nodos en primario (ejecutar en uno solo de los nodos)

# drbdadm -- --overwrite-data-of-peer primary opt_disk

Esto debera arrojar como resultado Primary/Secondary y Update/Update. Esto significa que el dispositivo /dev/drbd1 ya esta en proceso de sincronizacion.

HASTA AQUI los nodos ya ESTAN SINCRONIZADOS:

Creando el sistema de archivos, esto lo hacemos «solo una vez» en el nodo primario.

# mkfs.ext3 /dev/drbd1

Montamos el dispositivo para su uso en el nodo primario

# mkdir /rep
# mount /dev/drbd1 /rep

Y listo ! espero les sirva, feliz configuracion 🙂 .

Instalación y Configuración de un Controlador de Dominio Principal (PDC) SAMBA4 en CentOS 7

CentOS 7

CentOS (Community Enterprise Operating System) es una bifurcación a nivel binario de la distribución Linux Red Hat Enterprise Linux RHEL, compilado por voluntarios a partir del código fuente publicado por Red Hat, siendo la principal diferencia con este la eliminación de todas las referencias a las marcas y logos propiedad de Red Hat.

Es un sistema operativo de código abierto, basado en la distribución Red Hat Enterprise Linux, operándose de manera similar, y cuyo objetivo es ofrecer al usuario un software de «clase empresarial» gratuito. Se define como robusto, estable y fácil de instalar y utilizar. Desde la versión 5, cada lanzamiento recibe soporte durante diez años, por lo que la actual versión 7 recibirá actualizaciones de seguridad hasta el 30 de junio de 2024.

https://www.centos.org/download/

La versión de Kernel que utilizaremos es kernel-plus-3.10.0-862.el7.centos.plus.x86_64.rpm (11-May-2018) que viene con el ISO, pero recomendamos actualizar a la versión más actual en nuestro caso kernel-plus-3.10.0-862.6.3.el7.centos.plus.x86_64.rpm (03-Jul-2018). Para ver la lista oficial puedes visitar la siguiente dirección:

http://mirror.centos.org/centos/7/centosplus/x86_64/Packages/

Samba 4

Samba 4 Es una implementación libre del protocolo de archivos compartidos de Microsoft Windows (antiguamente llamado SMB, renombrado recientemente a CIFS) para sistemas de tipo UNIX. De esta forma, es posible que computadoras con GNU/Linux, Mac OS X o Unix en general se vean como servidores o actúen como clientes en redes de Windows. Samba también permite validar usuarios haciendo de Controlador Principal de Dominio (PDC), como miembro de dominio e incluso como un dominio Active Directory para redes basadas en Windows; aparte de ser capaz de servir colas de impresión, directorios compartidos y autentificar con su propio archivo de usuarios.

Samba 4 Soporta el directorio activo de windows a través de la combinación de varios elementos: Servidor de directorio LDAP, Servidor de autenticación Heimdal Kerberos, Servicio de DNS dinámico (a través de su propio servidor DNS o un plugin BIND)

Samba 4 puede proporcionar politicas de grupo, perfiles móviles y otras características para administrar sistemas en un dominio windows, además de integrarse con Servidores Exchange y alternativas compatibles Open Source.  El soporte de Samba para Active Directory es totalmente transparente para los clientes, lo que significa que un Controlador de Dominio basado en Samba puede ser integrado en un dominio existente de Active Directory.

Samba AD es estable para entornos de producción y puede ejecutarse como un controlador de dominio (DC) de Active Directory (AD). Si está instalando Samba en un entorno de producción, se recomienda ejecutar dos o más DC por razones de conmutación por error (Eso lo veremos en un artículo posterior).

Instalando SAMBA 4

A partir de la versión 4.0, Samba puede ejecutarse como un controlador de dominio (DC) de Active Directory (AD). En este tutorial, le mostraré cómo configurar Samba 4 como un controlador de dominio compilando Samba 4 desde el código fuente dado que algunas características AD no vienen incluidas por defecto en los paquetes de instalación.

Recomendaciones

Seleccione un nombre de host para su AD DC.

No utilice términos de solo NT4 como nombre de host, como PDC o BDC. Estos modos no existen en una AD y causan confusión.

Seleccione un nombre de dominio DNS para su bosque AD. El nombre también se usará como el reino de AD Kerberos.

Asegúrese de aprovisionar la AD usando un dominio DNS que no necesite cambiarse. Samba no admite el cambio de nombre de la zona AD DNS y el reino Kerberos.

Use una dirección IP estática en el DC.

Preparando la instalación

Verifique que no se estén ejecutando los procesos de SAMBA si existieran proceda a desinstalarlos:

 

# sudo su
# ps ax | egrep "samba|smbd|nmbd|winbindd"

 

Verifique el estado del módulo de seguridad para el kernel Linux que proporciona el mecanismo para soportar políticas de seguridad para el control de acceso (SELinux)

# sestatus

Instale el repositorio EPEL CentOS, Red Hat Enterprise Linux 7 no incluye todos los paquetes necesarios para construir un Samba AD DC. Habilite el repositorio externo de paquetes extra para Enterprise Linux (EPEL) antes de instalar los paquetes. Para más detalles, consulte https://fedoraproject.org/wiki/EPEL . Aunque la habilitación del repositorio EPEL no se requiere en CentOS 7 lo haremos d todas formas por si nos falta algún paquete.

# yum install epel-release -y

Paquetes necesarios para construir SAMBA

La siguiente es una lista independiente de sistema operativo de bibliotecas y utilidades necesarias para compilar e instalar Samba

Obligatorio

Bibliotecas y utilidades	Requerido para
pitón	Varias utilidades, como samba-tool el sistema de compilación ( Waf ), están escritas en Python.
Perl
acl	Se requiere solo en los controladores de dominio de Samba Active Directory y en los servidores miembros que usan las ACL de Windows .
xattr	Se requiere solo en los controladores de dominio de Samba Active Directory y en los servidores miembros que usan las ACL de Windows .
python-crypto	Samba AD DC solamente. Requerido samba-tool, por ejemplo, para establecer fideicomisos.

Para instalar estas y otras dependencias ejecute

 

# yum install attr bind-utils docbook-style-xsl gcc gdb krb5-workstation \
libsemanage-python libxslt perl perl-ExtUtils-MakeMaker \
perl-Parse-Yapp perl-Test-Base pkgconfig policycoreutils-python \
python-crypto gnutls-devel libattr-devel keyutils-libs-devel \
libacl-devel libaio-devel libblkid-devel libxml2-devel openldap-devel \
pam-devel pop-devel python-devel readline-devel zlib-devel systemd-devel

 

Obtener SAMBA

De acuerdo al “reléase planning”  de samba la última versión estable y con soporte es la 4.8.3 (Actualizado el 26 de junio de 2018). En este punto es recomendable situarse en la raíz seguidamente la descargamos con la herramienta “wget”:

# cd ~
# wget https://download.samba.org/pub/samba/stable/samba-4.8.3.tar.gz

El siguiente paso es extraer el empaquetado del código fuente y luego ingresar a la carpeta generada

# tar -zxf samba-4.8.3.tar.gz
# cd samba-4.8.3/

Ahora debemos configurar el paquete de instalación que utilizaremos con el comando “make”. El configure script permite personalizar varias opciones, como rutas de instalación. Aunque varias de las opciones ya vienen habilitadas por defecto especificaremos las opciones para realizar depuración y test. Además, también especificaremos el soporte para ads, winbind e integración al sistema. Seguidamente hacemos la instalación con “make”. (Esto tardara varios minutos).

# ./configure --enable-debug --enable-selftest --with-ads --with-systemd --with-winbind
# make && make install

Hacemos un test (opcional esto tardara bastante así que solo lo recomiendo en entornos de producción, también puede usar make quicktest ) y agregamos los directorios que contienen los comandos al PATH

# make test
# export PATH=/usr/local/samba/bin/:/usr/local/samba/sbin/:$PATH

Aprovisionamiento del Directorio Activo SAMBA 4

El proceso de aprovisionamiento de Samba AD crea las bases de datos de AD y agrega registros iniciales, como la cuenta de administrador de dominio y las entradas de DNS requeridas.

Agregar una entrada con el nombre “ip host.dominio host” en el /etc/hosts :

# cat /etc/hosts

127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
10.1.x.11  tu-server-01.tu-dominio.bo tu-server-01

En ambientes virtuales como en nuestro caso (vmware) es necesario deshabilitar la interfaz de red “virbr0”, caso contrario el aprovisionamiento no será el esperado. Recuerde tener solo una interfaz habilitada.

# systemctl stop libvirtd.service
# systemctl status libvirtd.service
# systemctl disable libvirtd.service
# reboot

Nosotros realizaremos el aprovisionamiento con rfc2307 habilitando varios niveles de compatibilidad y en modo interactivo.

# samba-tool domain provision --use-rfc2307 --interactive

Si percibe el siguiente mensaje “Unable to determine the DomainSID, can not enforce uniqueness constraint on local domainSIDs” paselo por alto, esto se debe a que este es el primer controlador de dominio instalado.

Configurando el servidor DNS

Los miembros de dominio en un AD usan DNS para localizar servicios, como LDAP y Kerberos. Para eso, necesitan usar un servidor DNS que sea capaz de resolver la zona AD DNS.

En el DC, configure el dominio AD DNS en el parámetro “search” y la IP de su DC en el parámetro “nameserver” del /etc/resolv.conf. Para esto puede usar el editor de red del administrador de red avanzado:

# nm-connection-editor

# cat /etc/resolv.conf
# Generated by NetworkManager
search tu-dominio.bo
nameserver 10.1.x.11
nameserver 8.8.8.8
nameserver 8.8.4.4

Configurando el firewall del S.O.

Agregaremos los puertos necesarios en el firewall del S.O. para resolver en especial DNS y permitir LDAP, asegúrese de que su firewall de red (si lo tiene) tenga también los permisos adecuados y evítese un dolor de cabeza.

# firewall-cmd --add-port=53/tcp --permanent
# firewall-cmd --add-port=53/udp --ermanent
# firewall-cmd --add-port=88/tcp --permanent
# firewall-cmd --add-port=88/udp --permanent
# firewall-cmd --add-port=135/tcp --permanent
# firewall-cmd --add-port=137-138/udp --permanent
# firewall-cmd --add-port=139/tcp --permanent
# firewall-cmd --add-port=389/tcp --permanent
# firewall-cmd --add-port=389/udp --permanent
# firewall-cmd --add-port=445/tcp --permanent
# firewall-cmd --add-port=464/tcp --permanent
# firewall-cmd --add-port=464/udp --permanent
# firewall-cmd --add-port=636/tcp --permanent
# firewall-cmd --add-port=1024-5000/tcp --permanent
# firewall-cmd --add-port=3268-3269/tcp --permanent

# firewall-cmd --reload

Comprobación de puertos

Para identificar los puertos y las interfaces de red en los que está escuchando el controlador de dominio (DC) de Active Directory (AD) de Samba, ejecute:

# netstat -plaunt | egrep "ntp|bind|named|samba|?mbd"

Para verificar puertos abiertos

# firewall-cmd --list-all

Además, el servicio AD DC requiere que se abran los siguientes puertos en el DC:

Service	Port	Protocol
DNS *	53	tcp/udp
Kerberos	88	tcp/udp
ntp **	123	udp
End Point Mapper (DCE/RPC Locator Service)	135	tcp
NetBIOS Name Service	137	udp
NetBIOS Datagram	138	udp
NetBIOS Session	139	tcp
LDAP	389	tcp/udp
SMB over TCP	445	tcp
Kerberos kpasswd	464	tcp/udp
LDAPS ***	636	tcp
Global Catalog	3268	tcp
Global Catalog SSL ***	3269	tcp
Dynamic RPC Ports ****	49152-65535	tcp

 

* Esto podría ser proporcionado por el servidor DNS interno de Samba, o el servidor DNS Bind9.
** Si ntp está configurado y ejecutándose en el DC.
*** Si tls enabled = yes (default) está establecido en su archivo smb.conf.
**** El rango coincide con el rango de puertos utilizado por Windows Server 2008 y posterior. Las versiones de Samba anteriores a 4.7 usaban los puertos TCP 1024 a 1300 en su lugar. Para configurar manualmente el rango de puertos en Samba 4.7 y posterior, configure el parámetro del puerto del servidor rpc en su archivo smb.conf.
Dependiendo de su instalación, los servicios que no sean samba pueden abrir puertos adicionales necesarios para su entorno de AD.

Para administrar vía RSAT (Windows 8.1 ingles, asegúrese de bajar el paquete adecuado) agregue

# firewall-cmd --permanent --zone=public --add-port=49152-65535/tcp
# firewall-cmd --reload

Configurando el inicio automático del servicio samba

Configuramos el daemon para el inicio automático del servicio, y habilitamos/levantamos el servicio.

# cat /etc/systemd/system/samba.service

[Unit]
Description= Samba 4 Active Directory
After=syslog.target
After=network.target

[Service]
Type=forking
PIDFile=/usr/local/samba/var/run/samba.pid
ExecStart=/usr/local/samba/sbin/samba

[Install]
WantedBy=multi-user.target

# systemctl enable samba
# systemctl start samba

Verificando el DNS

Para verificar que su configuración AD DNS funciona correctamente, consulte los siguientes 3 registros DNS _ldap SRV, _kerberos SRV y el registro A del controlador de dominio:

# host -t SRV _ldap._tcp.tu-dominio.bo
# host -t SRV _kerberos._udp.tu-dominio.bo
# host -t A sin-ldap-01.tu-dominio.bo

Uniendo un equipo Windows al Dominio

Utilizare una estación Windows 8 para fines de prueba, el equipo debe estar en la misma red y debe tener el DNS apuntando al nuevo AD:

Actualizado: Si desean unir al dominio equipos Linux pueden utilizar herramientas como PBIS-OPEN, yo la  he utilizado con distribuciones de escritorio Ubuntu y Kubuntu con muy buenos resultados ademas de facilitarme mucho la configuración. Claro que si deseas tener un mejor control de estas configuraciones recomiendo darle una vistazo a SSSD. Comparto una buena referencia sugerida por NATHAN a continuación:

https://www.sysadmit.com/2019/11/linux-anadir-equipo-al-dominio-windows.html

Suerte y feliz configuración 🙂 !

Referencias

https://es.wikipedia.org/wiki/CentOS
https://inspiretic.wordpress.com/2016/02/07/samba-4-vs-samba-3/
https://es.wikipedia.org/wiki/Samba_(software)
https://wiki.samba.org/index.php/Main_Page
https://www.centos.org/forums/viewtopic.php?t=63995
http://web.mit.edu/rhel-doc/3/rhel-sag-es-3/ch-lvm-intro.html
http://maslinux.es/5-formas-de-agregar-o-cambiar-el-nombre-de-host-en-rhelcentos-7/
https://www.linkedin.com/pulse/samba-4-active-directory-centos-7-aur%C3%A9lien-husson
https://sysarmy.com.ar/help/?qa=2496/samba-4-rsat-gpo
https://social.technet.microsoft.com/Forums/office/es-ES/1b2c261b-57c6-4e0a-9db2-717b6c3e7bdd/no-se-pudo-cambiar-el-nombre-dns-de-dominio-principal?forum=wsades
https://wiki.samba.org/index.php/Samba_AD_DC_Port_Usage

Extra
https://www.spinics.net/lists/samba/msg149792.html
https://askubuntu.com/questions/743819/connection-timed-out-no-servers-could-be-reached-error
https://www.putorius.net/2018/01/update-search-domains-on-red-hat-7.html
https://norfipc.com/redes/como-usar-comando-nslookup-windows.html
https://www.thegeekdiary.com/how-to-remove-virbr0-and-lxcbr0-interfaces-on-centos-rhel-5-and-rhel-7/

Oficial
http://mirror.centos.org/centos/7/centosplus/x86_64/Packages/
https://wiki.samba.org/index.php/Main_Page
https://wiki.samba.org/index.php/Setting_up_Samba_as_an_Active_Directory_Domain_Controller#Installing_Samba
https://wiki.samba.org/index.php/Setting_up_Samba_as_an_Active_Directory_Domain_Controller#Installing_Samba
https://wiki.samba.org/index.php/Build_Samba_from_Source

Guías
https://www.howtoforge.com/tutorial/samba-4-domain-controller-installation-on-centos/
https://www.linkedin.com/pulse/samba-4-active-directory-centos-7-aurélien-husson
http://www.mauriciomatamala.net/SO/sambadc.php

Instalación CentOS 7

CentOS (Community ENTerprise Operating System) es una bifurcación a nivel binario de la distribución Linux Red Hat Enterprise Linux RHEL, compilado por voluntarios a partir del código fuente publicado por Red Hat, siendo la principal diferencia con este la eliminación de todas las referencias a las marcas y logos propiedad de Red Hat.

Es un sistema operativo de código abierto, basado en la distribución Red Hat Enterprise Linux, operándose de manera similar, y cuyo objetivo es ofrecer al usuario un software de «clase empresarial» gratuito. Se define como robusto, estable y fácil de instalar y utilizar. Desde la versión 5, cada lanzamiento recibe soporte durante diez años, por lo que la actual versión 7 recibirá actualizaciones de seguridad hasta el 30 de junio de 2024.

https://www.centos.org/download/

La versión de Kernel que utilizaremos es kernel-plus-3.10.0-862.el7.centos.plus.x86_64.rpm (11-May-2018) que viene con el ISO pero realizaremos la actualización recomendada cambiándolo al más actual en nuestro caso kernel-plus-3.10.0-862.6.3.el7.centos.plus.x86_64.rpm (03-Jul-2018). Para ver la lista oficial puedes visitar la siguiente dirección:

http://mirror.centos.org/centos/7/centosplus/x86_64/Packages/

Inicio de instalación

Botee desde el CD de instalación, el asistente es bastante intuitivo solo siga los pasos y las capturas de pantalla ;), . También elegiremos la instalación con GUI por lo que seleccionaremos la opción «Servidor con GUI» en la sección «selección de software».

Destino de la instalación, en esta sección elegimos “Voy a configurar las particiones”. Esta parte la detallamos mejor en la sección “Esquema de particionamiento recomendado” de este manual.

Luego vamos a selección de software y elegimos «Servidor con GUI», esto instalara GENOME interfaz de usuario en servidor solamente.

Ahora empezamos la instalación

Añadimos la contraseña del «root» y añadimos el nuevo usuario (elegir «Hacer que este usuario sea administrador»)

Una vez terminada la instalación reiniciamos, la primera vez nos pedirá aceptar los términos de uso y listo !

Esquema de particionamiento recomendado

En Sistemas x86, AMD64, e Intel 64 se recomiendan las siguientes particiones para los sistemas x86, AMD64 e Intel 64:

• Una partición swap
• Una partición /boot
• Una partición /
• Una partición home

Puedes descartar la partición /home si no deseas almacenar datos de forma independiente de los datos del sistema ni actualizar o reinstalar CentOS7 sin borrar archivos de datos de los usuarios. Si desea realizar una configuración avanzada y personalizada de CentOS 7 visite la siguiente dirección:

https://access.redhat.com/documentation/es-es/red_hat_enterprise_linux/6/html/installation_guide/s2-diskpartrecommend-x86

Para nuestro caso (server virtual con 8 Gb RAM, 150 GB espacio en Disco) utilizaremos el siguiente esquema para nuestros puntos de montaje.

Directorio	Capacidad	Tipo Dispositivo	Sistema de Archivos
/	99 GB	LVM	ext4	Sistema
/swap	8 GB	LVM	swap	Memoria Virtual
/home	46 GB	LVM	ext4	Datos de Usuario
/boot	1 GB	Standar	ext4	Arranque

Utilice grupos de volumen lógico (LVM) para extender el tamaño en caso de quedarnos sin espacio. Recuerde ubicar siempre /boot en una partición diferente fuera del grupo de volumen lógico (LVM) porque el gestor de arranque no puede leerlo. Si la partición raíz / está en un volumen lógico, necesitará crear una partición /boot/ separada que no es parte de un grupo de volumen. Los sistemas de archivo recomendados son ext4 para tolerancia a fallos (también puedes usar el nuevo xfs si deseas). La partición swap siempre con el sistema de archivos swap.

Configuración de Red

Aplique configuración de la red mediante el “Administrador de Red“ : Aplicaciones, Herramientas del Sistema, Configuración, Red.

No olvide seleccionar la conexión automática “Conectar automáticamente” para que el sistema conecte a su red con cada reinicio y desactive IPv6

Lo siguiente es actualizar el sistema, debe tener conectividad a internet no olvide configurar su proxy adecuadamente. Si fuere necesario puede configurar la salida proxy en las configuraciones de red opción “proxy para la red” o también en su navegador Firefox en opciones avanzadas de red y de “conexión”. Para estar seguro de su conexión a internet realice ping a 8.8.8.8 y a google.com para probar la resolución de nombres (debería tener habilitado los puertos http 443, https 8080, ftp 8080 y 53/UDP – 53/TCP para trafico DNS), si la prueba no es satisfactoria consulte con su administrador de red.

# ping 8.8.8.8
# ping google.com

Si está utilizando un servidor proxy es necesario actualizar el archivo yum.conf para utilizar el comando de instalación “yum”

$ sudo  su
$ nano /etc/yum.conf

Y agregue la siguiente línea

proxy=http://ip-de-su-proxy:8080

Actualización del Sistema

Realice la actualización del sistema, esto es importante para resolver bugs conocidos y riesgos de seguridad en su sistema además de actualizar su versión de Kernel. (Esto tardara varios  minutos).

# yum sudo su
# yum list update
# yum update
# reboot

Antes

Despues

Verifica el nombre de tu equipo, puedes definirlo durante la instalación o puedes utilizar el siguiente comando:

# hostnamectl set-hostname “nombre-de-tu-equipo”

Suerte y feliz instalación
🙂

Referencias

http://mirror.centos.org/centos/7/centosplus/x86_64/Packages/
http://maslinux.es/5-formas-de-agregar-o-cambiar-el-nombre-de-host-en-rhelcentos-7/
http://web.mit.edu/rhel-doc/3/rhel-sag-es-3/ch-lvm-intro.html
https://access.redhat.com/documentation/es-es/red_hat_enterprise_linux/6/html/installation_guide/s2-diskpartrecommend-x86

LA CULPA ES SOLO NUESTRA

Despilfarramos agua, no reciclamos etc. Quizas algunos comentarios incendiarios o publicaciones falsas y oportunistas derroquen Gobiernos o Alcaldias, pero el problema continuara y las proximas generaciones pagaran por nuestra inconciencia y falta de unidad. Comentarios consumidos por resentimientos politicos, racistas o clasistas como: «raza maldita» o «cuello blanco» no aportan nada y a mi criterio son irresponsables por que provocan odio y enfrentamiento entre hermanos. … Aun tenemos tiempo.

NodeJS Logging con Winston & Morgan

Una aplicación básicamente debe proporcionar un sistema de registro que permita controlar mensajes de seguimiento (informativo, alerta, error, etc). Además del clásico console.log (del cual  no debemos abusar en producción) Node.js  cuenta con un buen soporte para el registro estructurado utilizando JSON para su posterior análisis. Dos de estas herramientas ampliamente recomendadas son  Winston y Morgan.

Que es Winston ?

https://github.com/winstonjs/winston

Winston es una librería diseñada para el  registro simple y universal con soporte para múltiples transportes. Un transporte es esencialmente un dispositivo de almacenamiento para sus registros. Dicho en palabras sencillas nos permiten almacenar mensajes personalizados de seguimiento (al igual que console.log) en un archivo plano o también desplegarlo por consola.

Que es Morgan ?

https://github.com/expressjs/morgan

Es un middleware para la captura de solicitudes HTTP para Node.js para su posterior registro y seguimiento.

Que es un Middleware ?

El middleware es un software o conjunto de componentes desarrollados que sirven para integrar aplicaciones.

---

Manos a la obra:

Primero creamos una aplicación node.js , yo trabajo sobre express (si deseas saber cómo crear una aplicación básica  express con Visual Studio puedes ver mi anterior articulo).   Me basare sobre este marco (express) para describir el ejemplo de este tema.

Instalación Winston:

npm install winston

A través del administrador de paquetes :

Instalación Morgan:

npm install morgan

A través del administrador de paquetes :

Uso básico de winston :

var winston = require('winston');
winston.level = 'debug';
winston.log('info', 'Escrito en consola !!!');
winston.info('Escrito en consola tambien !!!');

En este pequeño script primero definimos una variable haciendo referencia a winston , luego definimos el nivel de registro que vamos a desplegar y finalmente escribimos un mensaje.  Aquí hay dos puntos básicos pero muy importantes que explicar:

• El nivel define que tipos de mensajes serán desplegados, en este ejemplo para empezar solo mostramos mensajes en consola (no hemos definido un transporte para escribir el registro en un archivo de texto, eso lo veremos más adelante).
• Los niveles que maneja winston  son los siguientes: { error: 0, warn: 1, info: 2, verbose: 3, debug: 4, silly: 5 }

El las dos ultima líneas del script podrás observar que hemos escrito dos mensajes con el nivel “info” (las dos maneras de escribir un mensaje con winston son válidas). Como en la segunda línea definimos el nivel “winston”  en “debug “ el mensaje será desplegado  de la manera siguiente:

Si en cambio modificamos el script y mostramos un mensaje de tipo “silly“ en la última línea este mensaje no será desplegado dado que el nivel “debug : 4” esta por debajo de “silly:5”.

var winston = require('winston');
winston.level = 'debug';

winston.log('info', 'Escrito en consola !!!');
winston.silly('Escrito en consola tambien !!!');

Configurando Winston

Como había mencionado winston nos permite definir una configuración más estructurada. Si por ejemplo queremos desplegar registros de seguimiento por consola y en un archivo de texto es tan sencillo como esto:

var winston = require('winston');
    var logger = new winston.Logger({
        transports: [
            new winston.transports.File({
                level: 'debug',
                filename: './logs/logs.log',
                handleExceptions: true,
                json: true,
                maxsize: 5242880, //5MB
                maxFiles: 5,
                colorize: false
            }),
            new winston.transports.Console({
                level: 'info',
                handleExceptions: true,
                json: false,
                colorize: true
            })
        ],
        exitOnError: false
    });

    logger.silly("127.0.0.1 - there's no place like home");
    logger.debug("127.0.0.1 - there's no place like home");
    logger.verbose("127.0.0.1 - there's no place like home");
    logger.info("127.0.0.1 - there's no place like home");
    logger.warn("127.0.0.1 - there's no place like home");
    logger.error("127.0.0.1 - there's no place like home");

Este script permite el despliegue de mensajes en un archivo de texto (logs.log) y también por consola. Para poder lograr esto hemos definido dos capas de transporte propias de winston. En el anterior ejemplo las capas de transporte están definidas en esta sección de código:

transports: [
            new winston.transports.File({
                level: 'debug',
                filename: './logs/logs.log',
                handleExceptions: true,
                json: true,
                maxsize: 5242880, //5MB
                maxFiles: 5,
                colorize: false
            }),
            new winston.transports.Console({
                level: 'info',
                handleExceptions: true,
                json: false,
                colorize: true
            })
        ],

Las capas de transporte nos permiten definir múltiples tipos de salidas para nuestros mensajes. Si ejecutas este ejemplo podrás veras el siguiente resultado por consola:

Y el siguiente en el archivo de texto logs.log:

Como te podrás dar cuenta las dos capas de transporte tienen un nivel diferente (“info” para consola  y “debug” para archivo de texto) por lo que los mensajes que se desplegaran por  cada capa de transporte serán diferentes. En consola se mostraran solo los mensajes de tipo info, warn y error en cambio en el archivo de texto se mostraran los mensajes de tipo  info, warn, error, verbose y debug.

Otro apunte importante es definir la salida del  resultado de nuestros mensajes, por defecto las salidas no son desplegadas en formato JSON. Definir la salida en formato JSON nos permitirá realizar búsquedas en nuestro archivo de registro más fácilmente.

Utilicemos Morgan

Hasta ahora solo hemos desplegado mensajes personalizados y funciona a la perfección. Pero qué tal si también queremos capturar y desplegar mensajes de solicitud y respuesta HTTP como por ejemplo un error 404 Not Found ¿?

Con winston correctamente funcionando podemos combinar morgan para añadir esta funcionalidad. Para esto primero debemos definir un stream de los mensajes emitidos por winston:

logger.stream = {
    write: function (message, encoding) {
        logger.info(message);
    }
};

Y finalmente para combinar  Morgan añadimos nuestra funcionalidad combinada con Winston a nuestra aplicación:

app.use(require("morgan")("combined", { "stream": logger.stream }));

Como te abras dado cuenta solo para esta configuración especial debemos realizarla dentro de nuestro archivo de inicialización express  en mi caso app.js. Finalmente para este caso nuestro código quedaría así:

var winston = require('winston');
var logger = new winston.Logger({
    transports: [
        new winston.transports.File({
            level: 'debug',
            filename: './logs/logs.log',
            handleExceptions: true,
            json: true,
            maxsize: 5242880, //5MB
            maxFiles: 5,
            colorize: false
        }),
        new winston.transports.Console({
            level: 'info',
            handleExceptions: true,
            json: false,
            colorize: true
        })
    ],
    exitOnError: false
});

logger.stream = {
    write: function (message, encoding) {
        logger.info(message);
    }
}; 

app.use(require("morgan")("combined", { "stream": logger.stream }));

Si accedemos a un sitio no existente morgan captura el mensaje de respuesta y a través de winston el mensaje es desplegado en consola y en el archivo logs.log:

Y eso es todo espero les sirva,  hasta la próxima!
🙂

 

NodeJS, ExpressJS y AngularJS con SQL Server y Visual Studio 2015 Bueno bonito barato paso a paso.

Bueno por la potencialidad de estas herramientas hoy en día, bonito por lo sencillo de implementar como se verá en  este ejemplo, barato porque hablamos de software libre XD  (excepto SQL Server si no deseas usar la versión Express) incluso Visual Studio Community mi entorno de programación favorito que ahora es gratis para desarrolladores que deseen  crear sus propias aplicaciones gratuitas o de pago.

https://www.visualstudio.com/es-es/products/visual-studio-community-vs.aspx

Que es Node JS?

Node.js es un entorno Javascript del lado del servidor (Back End), basado en eventos. Node ejecuta javascript utilizando el motor V8, desarrollado por Google para uso de su navegador Chrome.

https://nodejs.org/en/

Que es NPM ?

npm (Node Package Manager) es una herramienta que nos permite instalar módulos adicionales para node.

Que es Express JS?

Espress.js, es un framework de desarrollo de aplicaciones web minimalista y flexible para Node.js

http://expressjs.com/es/

Que es Angular JS?

AngularJS es un framework JavaScript de desarrollo de aplicaciones web (Front End) en el lado cliente desarrollado por Google. Utiliza el patrón MVC (Model-View-Controller) y MVW (Model-View-Whatever). Entra dentro de la familia de frameworks como BackboneJS o EmberJS.

https://angularjs.org/

Que es Bootstrap ?

Bootstrap, es un framework originalmente creado por Twitter, que permite crear interfaces web con CSS y JavaScript, cuya particularidad es la de adaptar la interfaz del sitio web al tamaño del dispositivo en que se visualice.

http://getbootstrap.com/

Que es Jade ?

Jade es un “template engine”(motor de plantillas) de alto performance, enfocado en permitir escribir código HTML de forma rápida. Podríamos decir que se trata de un pre-procesador de código html; similar a stylus, sass o less con respecto a css

http://jade-lang.com/

http://miiquel.com/tutorial/generar-codigo-html-tutorial-jade-template/

Que es REST?

REST deriva de «Representational State Transfer», que traducido vendría a ser “transferencia de representación de estado”, podriamos decir muy vagamente que es una ruta url que nos devuelve resultado (generalmente JSON) o reproduce alguna acción

Que es JSON?

JSON (JavaScript Object Notation) es un formato para el intercambios de datos, básicamente JSON describe los datos con una sintaxis dedicada que se usa para identificar y gestionar los datos. JSON nació como una alternativa a XML.

Que es SQL Server?

Microsoft SQL Server es un sistema de manejo de bases de datos del modelo relacional, diseñado para el entorno empresarial desarrollado por la empresa Microsoft.

https://www.microsoft.com/es-es/server-cloud/products/sql-server/

Que es mssql node para sql server?

Es un un conector de base de datos desarrollado por Patrik Simek fácil de usar para MS SQL Server en Node.js.

https://www.npmjs.com/package/mssql

Para este articulo he utilizado: MS SQL Server 2012, Express 3.4.4, Node 4.3.0, Angular 1.5.0, mssql 3.1.2

---

Manos a la obra

PASO 1

Descarga e instala Visual Studio 2015 Community

Descarga e instala las herramientas de Node.js para Visual Studio 2015:

https://www.visualstudio.com/es-es/features/node-js-vs.aspx

PASO 2

Abre visual studio y crea un nuevo proyecto “ExpressApp”, veras que dentro de plantillas podras elegir varias para Node.Js elige  “Starter Node.js Express 3 Application”.

Como la descripción indica crearas un proyecto que incluye Express JS, Node JS además de BootStrap que solo nos servirá para la interfaz de usuario. También veras implementado Jade para html.

Si haces correr el proyecto (F5) veras una pagina basada en todo lo mencionado corriendo bajo node.js:

PASO 3

Descarga toda la librería angular y copiala toda a la siguiente ubicación del proyecto: public/js/lib/angular

https://angularjs.org/

PASO 4

Instala mediante NPM (botón derecho sobre npm) el paquete “mssql” para sql server

Existen también un par de paquetes oficiales desarrollados por  microsoft yo he preferido usar este porque lo veo bastante robusto para mis fines.

PASO 5

Vamos a agregar un “módulo de aplicación” angular para nuestro proyecto al que llamaremos “myApp”, para esto creamos un nuevo archivo js “myApp.js” en la carpeta “public/js” al que añadiremos el siguiente código angular:

var app = angular.module('myApp', []);

También crearemos nuestro controlador angular al que llamaremos “myCtrl”, para esto creamos un nuevo archivo js “myCtrl.js” en la carpeta “public/js” al que añadiremos el siguiente código:

app.controller('myCtrl', function ($scope, $http) {

    $http({
        method: 'GET',
        url: '/apiDepartamentos/Result'
    }).
    success(function (data, status, headers, config) {
        $scope.Result = data.Result;
    }).
    error(function (data, status, headers, config) {
        $scope.Result = 'Error Coyote!';
    });
});

Este controlador ademas realiza una petición a un REST denominado Result en la siguiente ruta ‘/apiDepartamentos/Result’. Para implementarlo crearemos un “api node” que realizara una sencilla consulta en base de datos y que nos devolverá una respuesta JSON. Para esto creamos un archivo js “apiDepartamentos.js” en la carpeta “routes” al que añadiremos el siguiente código:

exports.Result = function (req, res) {
    var sql = require('mssql');
    var conn = require('./connSQL.js');
    var connection = new sql.Connection(conn.connBJACENTRAL());

    connection.connect(function (err) {
        if (err) { res.status(500).send(err); return; }

        var request = new sql.Request(connection);

        var sqlString = 'SELECT COUNT(*) CT from Departamentos';
        request.query(sqlString, function (err, rs) {
            connection.close();

            if (err) { res.status(500).send(err); return; }

            var count = rs[0].CT;
            res.json({
                Result: count
            });
        });
    });
};

Como veras el ejemplo realiza una consulta sencillisima a la tabla “Departamentos” de una base de datos “Ejemplo” utilizando la librería msssql

var sql = require('mssql');

El script también hace referencia al archivo “connSQL.js”

var conn = require('./connSQL.js');

que mediante una función contiene los parámetros de conexión a la base de datos. Este archivo lo crearemos en la carpeta “routes” y contendrá el siguiente código node:

exports.connBJACENTRAL = function () {
    var config = {
        user: 'xxxx',
        password: 'xxxx',
        server: '192.168.100.x',
        database: 'Ejemplo',
        options: { encrypt: false }
    };

    return config;
};

Un apunte importante es el uso de la sentencia “exports”, que nos ayuda a definir métodos que podremos utilizar en cualquier ámbito de nuestra aplicación, esto para fines de modularización de nuestros proyectos.

La estructura de tu proyecto debería ser la siguiente:

En este punto ya podemos probar la conexión a base de datos, para este fin necesitamos agregar la ruta de nuestro api en el proyecto así que abrimos en la raíz el archivo “app.js” y añadimos primero la referencia a nuestro api :

var api = require('./routes/apiDepartamentos.js');

Ademas muy importante debemos enlazar la ruta de nuestro REST con nuestro api y por ende con nuestro controlador añadiendo también la siguiente línea de código:

app.get('/apiDepartamentos/Result', api.Result);

Pulsamos F5 y escribimos la siguiente ruta en el explorador (el puerto podría variar en el ejemplo):

http://localhost:1337/apiDepartamentos/Result

Como podrás ver nuestro REST nos devolverá un resultado JSON :

Si puedes ver lo mismo quiere decir que nos hemos conectado correctamente a sql server 😉 ademas que el resultado lo estamos direccionando correctamente en nuestro rest en “Result” que no es  mas que una consulta del número de registros de la tabla “Departamentos”

PASO 6

Referencia las librerías, aplicación y controlador angular en las vistas del proyecto, para esto abre el archivo “layout.jade” de la carpeta “views” y añade el siguiente código en la cabecera:

   script(src='js/lib/angular/angular.min.js')
   script(src='js/myApp.js')
   script(src='js/myCtrl.js')

Ahora mostremos el resultado con angular en una vista. Para esto abrimos el archivo index.jade de la carpeta “views”. Y añadimos la siguiente línea por el final:

  div(ng-app='myApp', ng-controller='myCtrl')
    h3 {{Result}}
    P Resultado Coyote !!!

Mucho cuidado con la sangría, Jade hace uso de las misma para formatear la salida html. Como podrás ver mediante “ng-app” y “ng-controller” enlazamos nuestra vista con nuestro módulo de aplicación y controlador angular. Finalmente mediante {{Result}} enlazamos el resultado de nuestro REST.

Si pulsas F5 el resultado debería ser el siguiente:

Si deseas descargarte el código fuente y base de datos ejemplo sigue este link:

https://drive.google.com/open?id=0B7cmVkykgga1MURhazdMamI0Vlk

Espero que esto te haya servido como una buena base para trabajar con estas fabulosas tecnologías. Saludos 🙂 !

Leyendo un archivo XML desde MS SQL Server 2012

Leer un archivo XML desde SQL Server 2012 es relativamente fácil. Para cumplir este objetivo hacemos uso de la función OPENROWSET que abre y analiza los datos en un XML. Primero para este ejemplo usaremos la siguiente estructura XML:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<blog>
<items>
<item>
<titulo>Titulo del primer artículo</titulo>
	<link>https://freddyach.wordpress.com/articulo/primero.html</link>
<descripcion>
Breve descripción del contenido de este artículo concreto. Puedes usar un
par de líneas para crear esta descripción, aunque no hay ningún tope máximo. </descripcion>
</item>

<item>
<titulo>Título de un segundo artículo</titulo>
	<link>https://freddyach.wordpress.com/articulo/segundo.html</link>
<descripcion>
Breve descripción del contenido del otro artículo. Puedes usar un
par de líneas para crear esta descripción, aunque no hay ningún tope máximo. </descripcion>
</item>
</items>
</blog>

Para abrirlo desde SQL simplemente usamos usamos :

DECLARE @x xml
SELECT @x = P
FROM OPENROWSET(BULK 'C:testBlogEjemplo.xml', SINGLE_BLOB) AS Datos(P)
SELECT @x

Este es el resultado:

Ahora bien para hacer un select de los elementos de nuestro XML usaremos el siguiente código:

-- Nos conectamos al documento usando toda la información de conexión
-- necesaria para tener acceso a datos desde el origen XML.
-- Usamos BULK para leer un archivo
DECLARE @x xml
SELECT @x = P
FROM OPENROWSET(BULK 'C:testBlogEjemplo.xml', SINGLE_BLOB) AS Datos(P)

SELECT @x

-- Leemos el texto de XML proporcionado como entrada,
-- analizando el texto con el analizador MSXML sp_xml_preparedocument

DECLARE @hdoc int
EXEC sp_xml_preparedocument @hdoc OUTPUT,@x

-- Realizamos la consulta al XML segun la estructura (Primer nodo "Blog", segundo "Item")
-- usando OPENXML.
SELECT *
FROM OPENXML (@hdoc, '/blog/items/item',2)
WITH (
titulo nvarchar(100),
link nvarchar(100),
descripcion nvarchar(100)
)

-- Liberamos memoria
EXEC sp_xml_removedocument @hdoc

Este es el resultado

Notas. Deben ser usuarios elevados para ejecutar estos comandos, XML distingue mayúsculas y minúsculas en el path, habiliten cmdshelld de MSSQL. Espero les sirva saludos 🙂 !

MVC .NET – Tipos de inicialización de base de datos con Entity Framework Code First

De aquí para allá en el mundo TI (Base de Datos ,Infraestructura, Redes y Servidores), pero siempre metido a la programación por hobby y con un poco mas de tiempo de apoco empezando a publicar un poco de todo …

Hay varios tipos de inicialización de base de datos en Entity Framework Code First, los cuales explico a continuación:

CreateDatabaseIfNotExists: Es el tipo de inicialización establecido por defecto, y solo crea la base de datos si esta no existe, es decir la primer vez que ejecutemos la inicialización a no ser que eliminemos la base de datos y volvamos a ejecutar, hay que tener en cuenta que si trabajamos con esta inicialización y cambiamos nuestro modelo obtendremos un error.

DropCreateDatabaseIfModelChanges:  Este tipo de inicialización elimina la base de datos existente y la crea de nuevo con las actualizaciones, siempre y cuando existan cambios en nuestro modelo de clases, la desventaja con esto es que tendremos perdida de datos.

DropCreateDatabaseAlways: Este tipo de inicialización elimina la base de datos existente y la crea de nuevo sin importar si hay nuevos cambios en el modelo o no. esto siempre conllevara perdida de datos y problemas de rendimiento al siempre tener que crear la base de datos.

Custom DB Initializer: Adicional podemos crear nuestro propio inicializador de base de datos si necesitamos algo muy específico, otro tipo de configuraciones, o ejecutar otro proceso externo para la inicialización, para esto podemos crear una clase que herede de una clase de inicialización cómo por ejemplo MigrateDatabaseToLatestVersion u otro de los mencionados.

MigrateDatabaseToLatestVersion: Nos permite actualizar automáticamente la base de datos, una vez inicie la aplicación, las actualizaciones pendientes se reflejaran en nuestra base de datos, este tipo de inicialización nos permite conservar los datos obviamente si no se trata de una instrucción Drop o Delete por ejemplo. Con este tipo es que podremos implementar migraciones en nuestra aplicación.

Espero les sirva saludos 🙂 !

MVC 3, Un poquito de lo visto hasta ahora

Olvídate del doble clic y los eventos donde antes generabas tu código, del pesado render, de los complicados manejadores de eventos. Este nuevo modelo propone realizar la programación algo parecida a la vieja usanza ASP donde el código se embebía dentro el HTML.

Adentrándome a este modelo de programación no me arrepiento, ya que trae interesantes ventajas como ser: respuesta más rápida y control total del código fuente.
MVC viene perfectamente integrado al nuevo EF(Entity FrameWork) de Visual Studio 2010, en los que tropecé con algunos enfoques:

• Date First Generación del modelo a partir de la base de datos (Lo más apropiado para mis necesidades actuales, ya que poseo bases de datos a partir de las cuales puedo abstraer fácilmente el modelo además de generarme todo el código automáticamente)
• Code First Generación del modelo a partir de código .NET (Con clases POCO, no necesitas MS SSMS, mmm me parece una pequeña exageración ggg ^^.)
• Model First Generación del modelo a partir de del propio modelo (Usando el propio diseñador de clases en VS Studio 2010 y partir del mismo generar la base de datos)

Lo mejor de todo es que todo viene perfectamente soportado en EF (Entity FrameWork), así que puedes elegir, según tus necesidades. Te recomiendo este tutorial:

http://www.asp.net/mvc/tutorials/getting-started-with-mvc3-part1-cs
Observaciones del tutorial:
Se hace referencia a : «using System.Data.Entity.Database» cuando deberia ser :»using System.Data.Entity» para utilizar : «Database.SetInitializer»
Auteticación sql no funciona para Database.SetInitializer al menos en mi caso.
Los datos añadidos mediante Seed(MovieDBContext context)no son desplegados en la grilla luego de la actualización de base de datos con Database.SetInitializer

Salu2.