Forem: Jonathan Pumares

Introducción a la nube

Jonathan Pumares — Mon, 29 Nov 2021 20:35:15 +0000

Seguramente montaste tu primera aplicación o sitio web en un hosting compartido, ese servidor en donde tenias que compartir sus recursos con otras personas y subir el código a través de FTP, desde ese entonces, la web a evolucionado a pasos agigantados, dando lugar a todo un conjunto de servicios y soluciones para cada necesidad y para cada empresa.

Ahora no solamente puedes contratar un servidor, sino tienes a tu disposición múltiples servicios que puedes utilizar para tus próximos proyectos o en tu empresa, desde servidores, almacenamiento, bases de datos, redes, software, entre muchos servicios más.

Estos servicios que te acabo de mencionar pueden agruparse en tres categorías principales. Pero antes de entrar en detalles veamos qué es la nube.

¿Qué es la nube?

Es posible que lo primero que se te venga a la mente, son esos satélites que se encuentra en órbita alrededor de la Tierra, pero no, eso definitivamente no es la nube. ¿Qué si es la nube? Es todo ese conjunto de servidores (supercomputadoras con mucho poder de cómputo) distribuidos en distintas zonas geográficas a través del mundo, que nos proveen de estos servicios.

¿Quién es dueño de estos servidores?

En realidad se les conoce como proveedores de nube, y son todas aquellas empresas que nos ofrecen y permiten acceder a estos servicios informáticos que ya te mencione. Es muy similar a cuando contratas tu servicio de Internet, en donde tienes distintas opciones por elegir y terminas escogiendo la que más se ajusta a tu presupuesto y necesidades.

¿Qué proveedores de nube podemos elegir?

La gran cantidad de opciones que tenemos es muy variada y elegir una dependerá de distintos factores, como las necesidades del proyecto, el tamaño de la empresa, la infraestructura que se cuenta actualmente, si deseas migrar a la nube, etc.

Aquí te mostraré los proveedores de nube más utilizados en la industria tech:

Amazon Web Services (AWS)

El gigante de las compras en línea ofrece más de 200 de servicios integrales a nuestra disposición.

Sí conoces acerca de AWS y su funcionamiento tienes una oferta laboral garantizada ya que es de los proveedores de nube más utilizados por las empresas. Además en su propio sitio ofrece un programa de formación en línea para que te certifiques a través de sus cursos.

Sitio web: https://aws.amazon.com/

Microsoft Azure

La cantidad de servicios que ofrece, la hace una opción muy atractiva. Aparte tiene integración con distintas tecnologías como C#, Python, entre otras.

Microsoft ofrece a todas aquellas personas que quieren aprender sobre la nube y Azure una plataforma de aprendizaje llamada de Microsoft Learn, donde al igual que en AWS tienes la posibilidad de que te certifiques en el uso de sus tecnologías.

Un dato interesante es que Microsoft cuenta con la mayor cantidad de data centers en el mundo, así que es casi seguro que puedes contratar cualquier servicio de Azure en una ubicación cerca de ti.

Sitio web: https://azure.microsoft.com/

Google Cloud

El búscador más grande de Internet, igualmente ofrece sus servicios en la nube, y es junto a AWS y Azure de los más utilizados por las empresas, ofreciendo servicios como hospedaje web, almacenamiento y desarrollo de aplicaciones que se ejecutan directamente en los servidores de Google.

Sitio web: https://cloud.google.com/

DigitalOcean

Una opción muy interesante si quieres iniciarse en este mundo de los servicios en la nube, ya que ofrece un VPS (Virtual Private Server) que ellos llaman Droplets, por solo 5 dólares por mes, una opción muy económica para que experimentes el poder de la nube.

DigitalOcean tiene una gran comunidad en donde comparten una gran cantidad de tutoriales muy interesantes, desde como configurar por primera vez tu servidor de manera correcta, hasta instalar todas las herramientas que necesitas para montar tu aplicación.

Sitio web: https://www.digitalocean.com/

IBM Cloud

IBM Cloud ofrece soluciones para entornos corporativos, lo que la hace una opción muy interesante, ya que se adapta muy bien a las principales necesidades de las organizaciones, desde el requerimiento más sencillo hasta soluciones complejas con Inteligencia Artificial (IA).

Sitio web: https://cloud.ibm.com/

Modelos de servicio en la nube

Ya que conoces algunos de los proveedores de nube más utilizados, te había mencionado que todo este conjunto de servicios que ofrecen podemos clasificarlos en tres categorías principales, pero antes de entrar en contexto con esta clasificación déjame contarte que existe la posibilidad en donde la infraestructura de tu empresa o proyecto aún se encuentre en un entorno local, es decir, dentro de las instalaciones de la propia organización, en donde somos responsables de administrar cada uno de los elementos de la infraestructura, como servidores, virtualización, aplicaciones, etc.

Aunque está sigue siendo una opción muy válida, la idea de migrarse a la nube tiene dos ventajas:

Para los administradores de sistemas es un alivio, ya que no tendrán que preocuparse más por la administración de los servidores locales de la organización, sino dependiente del modelo de servicio que se contrate se va teniendo menos responsabilidades por administrar. Te dejo la siguiente imagen en donde puedes visualizar que elementos son los que administra el usuario y que elementos administra el proveedor dependiendo del modelo de servicio:

Fuente: https://docs.microsoft.com/learn/modules/align-requirements-in-azure/3-service-models

La segunda ventaja es que los servicios en la nube ofrecen un modelo basado en consumo lo que significa que solamente pagas por lo que usas. En caso contrario, en un modelo On-Premises o local, tienes que invertir en infraestructura física, que es deducible a larzo plazo.
Voy a mencionarte una ventaja más que se relaciona con la ventaja anterior, y es que la nube nos ofrece los recursos necesarios para que nuestra aplicación funcione de manera optima, imagina que por temporada tu aplicación tiene un aumento en el número de usuarios que la consultan de manera recurrente, la nube nos permite escalar los recursos de manera fácil y sencilla, y cuando termine esa temporada podemos reducir los recursos para no afectar la factura del mes. En el caso del modelo On-Premises o local, tendrías que invertir en memoria RAM y otros recursos si quieres aumentar la capacidad de tus servidores. Pero aquí no puedes devolver los recursos que ya has comprado, por lo que es una inversión a largo plazo.

Ahora si vayamos a los 3 principales modelos de servicio en la nube.

Infraestructura como servicio (IaaS)

En este tipo de modelo de servicio, el proveedor proporciona al cliente acceso directo a infraestructura tecnológica, como servidores, bases de datos y otros recursos en la nube.

Plataforma como servicio (PaaS)

El proveedor proporciona a los usuarios acceso a un entorno de nube en el que pueden desarrollar, gestionar y entregar aplicaciones. En este modelo prácticamente el proveedor se encarga de ofrecer y administrar la infraestructura mientras que el usuario se preocupa de desarrollar y entregar la solución.

Software como servicio (SaaS)

Los usuarios tienen acceso a un software que se encuentra en la nube a través de una suscripción, accediendo por medio de la web desde un navegador o por medio de las API del proveedor.

¿Tienes cuenta en Spotify o Netflix? Estás usando un Software como servicio.

Tu camino hacia el cloud computing apenas comienza

Ahora que conoces todo lo que ofrece la nube, te invito a seguir aprendiendo más acerca del cloud computing, ya que tendrás mejores oportunidades laborales, porque cada vez más empresas están migrando a la nube y necesitan de profesionales que les ayuden en ese proceso de migración.

No dudes en compartir este post si te ha parecido genial.

Cómo instalar y configurar phpMyAdmin para tu entorno de desarrollo

Jonathan Pumares — Fri, 19 Nov 2021 22:24:22 +0000

Cuando estamos en la etapa de desarrollo de nuestro sistema, solución o aplicación, necesitamos visualizar los detalles que contiene nuestra base de datos, ya sea consultar información, crear una nueva base de datos para el proyecto, correr un script para generar la estructura de la misma base de datos, insertar los datos, etc.

Para ello existen una gran variedad de clientes gráficos que podemos utilizar para conectarnos a nuestro servidor de base de datos. En esta ocasión quiero hablarte de phpMyAdmin, uno de mis clientes de bases de datos para MySQL favoritos, que utilizo para mi entorno de desarrollo.

Pero primero déjame contarte que es phpMyAdmin.

¿Qué es phpMyAdmin?

Es una herramienta de software libre escrita en PHP, para manejar la administración de bases de datos MySQL y MariaDB, y todo desde tu navegador favorito. Que sea meramente un cliente de interfaz gráfica no limita que no puedas utilizar sentencias SQL desde la propia interfaz.

¿Qué puedes hacer con phpMyAdmin?

Si hay algo que me encanta de phpMyAdmin es su interfaz intuitiva para tener todo a la mano desde unos cuantos clics.

Además de que cuenta con una cantidad de características para que la administración desde la interfaz sea más fácil.

Déjame decirte algunos:

Navega entre tus bases de datos, tablas, campos, índices y vistas de una manera sencilla
Crea, copia, elimina, renombra y modifica bases de datos, tablas y campos
Administra los usuarios y privilegios de MySQL
Importa datos desde archivos CSV y scripts SQL
Exporta datos a varios formatos: CSV, SQL, XML, PDF y otros
Administra múltiples servidores
Y muchas más...

¿Aún no te convences?

Si aún no te convence utilizar phpMyAdmin, en su sitio oficial cuenta con una demo que puedes probar para que vayas viendo todas las posibilidades que tienes al usar esta herramienta.

Ve al sitio web oficial https://www.phpmyadmin.net/ y del lado superior derecho encontrarás un botón color verde con la leyenda "Try demo", da clic en el botón y te abrirá enseguida la interfaz gráfica para que interactues con la demo. Prueba todas las opciones y dime que te parecen.

Instalando y configurando phpMyAdmin

Si ya estas listo para empezar a usar phpMyAdmin vayamos a instalar y configurar esta maravillosa herramienta.

Existen muchas maneras de instalar phpMyAdmin, empezaremos viendo las opciones que tenemos para cada sistema operativo y luego veremos cómo hacerlo de forma manual independiente del sistema operativo que tengamos.

Instalando phpMyAdmin usando XAMPP

La manera más fácil de instalar phpMyAdmin en Windows, Linux o macOS es usando un paquete de terceros que ya incluya phpMyAdmin, por lo que no tenemos que preocuparnos por instalarlo y configurarlo de manera separada.

Uno de esos paquetes es XAMPP, que es un conjunto o stack de tecnologías para montar tu entorno de desarrollo de una manera sencilla y que te incluye todo lo necesario para que empieces a desarrollar tus aplicaciones con PHP.

Qué es lo que incluye XAMPP:

Apache como servidor web
MariaDB como servidor de base de datos
PHP como lenguaje de programación
phpMyAdmin como cliente gráfico de bases de datos MySQL y MariaDB
Entre otras herramientas más...

Si algo caracteriza a XAMPP es que el proceso de instalación para cada sistema operativo es muy sencillo, por lo que solamente tienes que descargar y ejecutar el instalador. Aquí te dejo la página para que lo descargues y lo instales en tu sistema operativo.

Instalación manual

En caso de que tengas otro entorno de desarrollo diferente a XAMPP y que no incluya directamente phpMyAdmin tendremos que realizar la instalación manual de phpMyAdmin, pero no te preocupes ya que esto es muy sencillo.

¿Quieres conocer qué otros entornos de desarrollo puedes instalar?

Te dejo la siguiente infografía de Guardianes del Código:

Y el siguiente video para que conozcas más detalles de estas herramientas:

Ahora si vayamos a la instalación:

Ve al sitio web oficial https://www.phpmyadmin.net/ y del lado superior derecho encontrarás el botón verde con la leyenda Download, enseguida se descargará un archivo .zip con el siguiente formato phpMyAdmin-<version>-all-languages.zip y que puedes guardarlo por el momento en cualquier ubicación de tu sistema de archivos.
Descomprime el archivo .zip, si lo descomprimes directamente se guardará todo dentro de una carpeta con el siguiente formato phpMyAdmin-<version>-all-languages, te recomiendo renombrar el nombre de la carpeta por algo más sencillo como phpmyadmin.
Identifica la carpeta root en donde tu entorno de desarrollo sirve o ejecuta directamente los archivos PHP. Si estas usando Laragon con Windows muy posiblemente esa ubicación sea C:\laragon\www, en otros entornos se conoce como htdocs. Copia en esa ubicación la carpeta phpmyadmin junto con todo su contenido.
Verifica que estes ejecutando los servicios de tu entorno de desarrollo, es decir que tengas corriendo tanto tu servidor web como tu servidor de base de datos.

Configuración de phpMyAdmin

Abre tu editor de texto favorito y crea en la raíz de la carpeta phpmyadmin un archivo llamado config.inc.php, puedes copiar el contenido del archivo config.sample.inc.php que se encuentra igualmente en la raíz de la carpeta phpmyadmin.
Ahora editaremos el archivo config.inc.php, quiero que te des cuenta en estas líneas de código:

/**
 * Servers configuration
 */
$i = 0;

/**
 * First server
 */
$i++;
/* Authentication type */
$cfg['Servers'][$i]['auth_type'] = 'cookie';
/* Server parameters */
$cfg['Servers'][$i]['host'] = 'localhost';
$cfg['Servers'][$i]['compress'] = false;
$cfg['Servers'][$i]['AllowNoPassword'] = false;

Si te das cuenta en esas líneas de código estamos configurando nuestro primer servidor en el que nos conectaremos, como te había mencionado, la ventaja de phpMyAdmin es que nos podemos conectar a múltiples servidores de bases de datos MySQL.

En esa configuración nos hace falta agregar el usuario y la contraseña de nuestro servidor. Por lo general, en la mayoría de los entornos de desarrollo para PHP viene configurado por defecto en el servidor de bases de datos MySQL, un usuario "root" sin contraseña.

Debes tomar en cuenta que se trata solamente de tu entorno de desarrollo en tu máquina local, por lo que tener un usuario "root" sin contraseña esta bien, pero no en un entorno en producción, en el que debes considerar unas configuraciones extras de seguridad para tus bases de datos.

Por lo que las líneas ahora quedarían de la siguiente manera:

/**
 * Servers configuration
 */
$i = 0;

/**
 * First server
 */
$i++;
/* Authentication type */
$cfg['Servers'][$i]['auth_type'] = 'config';
/* Server parameters */
$cfg['Servers'][$i]['host'] = '127.0.0.1';
$cfg['Servers'][$i]['user'] = 'root';
$cfg['Servers'][$i]['password'] = '';
$cfg['Servers'][$i]['compress'] = false;
$cfg['Servers'][$i]['AllowNoPassword'] = true;

Bueno te explico los cambios que se hicieron, el primero es el cambio en el valor de $cfg['Servers'][$i]['auth_type'] a config, esto evita estar introduciendo a cada rato el usuario y contraseña en la pantalla de inicio de sesión en phpMyAdmin.

Luego el valor en $cfg['Servers'][$i]['host'] se cambio a 127.0.0.1, esto garantiza que nos conectemos correctamente a nuestro servidor local.

Ahora en $cfg['Servers'][$i]['user'] ponemos el usuario para conectarnos a nuestro servidor de base de datos, si tienes uno diferente a "root", cambialo en su lugar. En $cfg['Servers'][$i]['password'] pon la contraseña de tu servidor local, como te habia mencionado por lo general en un entorno local el usuario root no tiene contraseña, si manejas otro usuario o le pusiste contraseña a tu usuario "root" ponlo en su lugar.

Por último en $cfg['Servers'][$i]['AllowNoPassword'] se cambio a true ya que es muy probable que tu usuario "root" no tenga contraseña y si no cambias su valor no te dejará conectarse sin una contraseña.

Ya que tenemos todas nuestras configuraciones listas, es tiempo de probar en el navegador que todo funcione correctamente. Abre tu navegador y escribe la dirección hacia phpMyAdmin, si usas host virtuales en tu entorno de desarrollo, muy probablemente entres a una dirección como esta phpmyadmin.test, en caso de que no manejes host virtuales, muy probablemente entres a localhost/phpmyadmin.
Verás enseguida la interfaz de administración de phpMyAdmin, ahora podrás interacturar con todas tus bases de datos y probar todas las ventajas que nos ofrece.

Y de esa manera es como tienes desde tu navegador una herramienta para administrar tus bases de datos en tu entorno de desarrollo.

Como nota adicional quiero decirte que no descartes la posibilidad de aprender o seguir utilizando tu linea de comandos para administrar tu servidor de base de datos, ya que posiblemente en algún momento vas a interactuar con algún servidor de producción que no precisamente cuenta con una interfaz gráfica, si no que todo es a través de comandos.

Cuéntame en los comentarios, ¿Ya conocías phpMyAdmin?, ¿Qué cliente de base de datos usas en tu día a día para administrarlas?

No dudes en compartir este post si te ha parecido genial, y dime que te gustaría en próximos posts, estaré encantado de compartir contigo para que aprendamos juntos.

Roles en proyectos de software

Jonathan Pumares — Mon, 08 Nov 2021 17:09:03 +0000

En la etapa de inicio de un proyecto necesitamos identificar los roles que ayudarán en el éxito de un proyecto de software.

Estos roles pueden dividirse en dos grupos: equipo creativo y lideres técnicos.

Cabe aclarar que dependiendo del tipo de proyecto y presupuesto, una persona puede ocupar varios roles dentro del equipo.

Describiremos cada uno de estos roles, empezando por el equipo creativo, en donde su principal tarea es construir el software que usarán los usuarios o personas interesadas.

Equipo creativo

El equipo creativo es el encargado de dar vida al software desde la etapa de diseño, pasando por el desarrollo, pruebas y la implementación de la solución. Este no es un proceso que se realice una sola vez, es un proceso iterativo que requiere feedback de los usuarios para mejorar el producto.

UI/UX Designers

Son las personas encargadas de diseñar la interfaz de usuario y de hacer los primeros prototipos a nivel visual de la aplicación.

Están en constante comunicación con los clientes o usuarios de la aplicación para recibir retroalimentación de si van por el camino correcto.

Front-end developers

Son las personas encargadas del aspecto visual de la aplicación, de hacer realidad los diseños hechos por los diseñadores y de darle interactividad a los componentes mostrados al usuario, como botones, formularios, etc.

Backend developers

Son las personas encargadas de la lógica de negocios de la aplicación, de trabajar con servidores y bases de datos. Se aseguran de guardar, consultar y proteger los datos, hacen posible que la aplicación funcione a nivel operativo usando lenguajes de programación como Python, PHP, .NET, Java, por mencionar algunos.

DevOps

Es el equipo encargado de implementar toda la infraestructura que hace posible mantener funcionando la aplicación para los usuarios, trabajan con servidores, sistemas operativos y se encargan de la seguridad informática de la aplicación.

Es posible que un Backend developer haga trabajo de Devops ya que comparten conocimientos en común cómo los lenguajes de programación, manejo de servidores y sistemas operativos, uso de la consola, entre otros.

Developer Roadmaps

Si quieres conocer el roadmap o la ruta que debes seguir para convertirte en desarrolladora o desarrollador web, te comparto el siguiente recurso para que puedas escoger entre Front-end, Backend y/o DevOps

Lideres técnicos

Parte del proceso creativo de un proyecto es guiarlo por el camino correcto, de hacer cumplir con los entregables del proyecto y, del crecimiento y motivación del equipo.

Stakeholders

Son todas aquellas personas interesadas en la realización del proyecto, y en la mayoría de los casos quienes manejan el presupuesto. Aquí entran los dueños o directivos de la empresa que tienen una amplia visión del negocio y un gran impacto en la realización del mismo.

Product Owner

Es la persona encargada de hacer cumplir con los entregables del proyecto y de definir nuevos requerimientos para la siguiente iteración. Debe conocer el modelo de negocio y esta en constante comunicación con el equipo creativo para revisar que se cumplan con dichos requerimientos.

Product Manager

Es una persona experta en tecnología y líder del equipo creativo, se encarga de lidiar con los obstáculos que le impiden a su equipo avanzar y de cumplir con las fechas de entrega establecidas. De igual manera sabe transformar las ideas de negocio en tecnología y de supervisar que se cumpla con cada iteración.

Cuéntame en los comentarios, ¿Qué otros roles consideras importantes en proyectos de software?

Configura tu entorno de desarrollo de manera profesional con Python y Django

Jonathan Pumares — Tue, 31 Aug 2021 22:45:02 +0000

Configurar tu entorno de desarrollo de manera profesional te ayudará a ahorrarte mucho tiempo, y en esta ocasión veremos como configurar tu entorno de desarrollo para que trabajes con Python y Django desde Visual Studio Code, el editor de texto favorito para muchos.

¿Qué es Django?

Django es un framework de Python para desarrollo web, que nos permite crear y mantener aplicaciones web de una manera rápida, segura y escalable.

Requerimientos

Git
Visual Studio Code
Instalar la extensión de Python para VS Code
Python 3.6 o superior

Configura un repositorio de Git en tu proyecto

Git es una herramienta esencial para cualquier proyecto de software, que permite compartir código, participar en un proyecto open source o manejar las versiones de tu aplicación.

Es por ello que te invito a usar Git en tus proyectos, y en este no será la excepción, vamos a inicializar un repositorio de Git, creando primero una carpeta para el proyecto:

En tu sistema de archivos, crea una carpeta para tu proyecto, puedes llamarla como tu quieras, en este ejemplo la llamaremos proyecto_django.
Abre tu consola desde la ubicación de tu carpeta proyecto_django y ejecuta el siguiente comando para inicializar un repositorio de Git:



git init

El siguiente paso es crear un archivo .gitignore, que permitirá ignorar archivos que no queremos darle un seguimiento a través del sistema control de versiones, estos pueden ser archivos de configuración, que contienen datos sensibles como contraseñas, archivos binarios, como imágenes, ya que suelen ser muy pesados, archivos de compilación de Python (.pyc), etc.

Abre la carpeta de tu proyecto desde Visual Studio Code, ya sea ejecutando el comando code . desde tu consola o abriendo Visual Studio Code y en la opción File > Open Folder.
Crea el archivo .gitignore en la raíz de la carpeta del proyecto, y no olvides agregar el punto (.) al principio del nombre.

¿Qué contendrá este archivo .gitignore?

El archivo .gitignore contendrá una lista de todos los archivos que vamos a ignorar, y para crear esa lista nos apoyaremos de la página https://gitignore.io que nos facilitará la creación de este archivo pasándole un conjunto de etiquetas de todas las herramientas que utilizaremos.

Para este caso, pasamos las etiquetas VisualStudioCode, Python y Django:

Damos clic al botón Create y enseguida nos aparecerá todo un conjunto de archivos que son utilizados por estas herramientas, pero que no es necesario darles un seguimiento en nuestro repositorio. Copia el contenido y pégalo en tu archivo .gitignore.

Crear un entorno virtual para nuestro proyecto de Django

Un entorno virtual nos permitirá instalar todos los paquetes y librerías necesarias para tu proyecto de manera independiente, es decir, podremos probar distintas versiones de Django sin entrar en conflicto con otros proyectos. Piensa en un entorno virtual como una máquina virtual, capaz de aislar todos los paquetes instalados dentro de ese entorno virtual.

Ahora vayamos a la creación del entorno virtual:

Dentro de tu carpeta principal del proyecto, desde la línea de comandos, ejecuta el siguiente comando para crear un entorno virtual llamado venv (asegurate de tener instalado Python):



# Linux
sudo apt-get install python3-venv # En caso necesario de no contar con python3-venv
python3 -m venv venv

# macOS
python3 -m venv venv

# Windows
python -m venv venv

En Visual Studio Code tenemos que seleccionar el intérprete de Python que se utilizará para ejecutar nuestro proyecto. Ahí es donde entra el entorno virtual que acabamos de crear. Prácticamente le decimos a VS Code, quiero que utilices la versión de Python que tengo dentro de mi entorno virtual junto con todos sus paquetes instalados.

Dentro de VS Code, vamos a la opción View > Command Palette y seleccionamos el comando Python: Select Interpreter

El comando mostrará una lista de los intérpretes disponibles que VS Code puede localizar automáticamente. Desde la lista, selecciona el entorno virtual que se encuentra dentro de la carpeta del proyecto:

Hasta este momento solamente hemos creado nuestro entorno virtual, pero aún no lo usamos, para ello tenemos que activarlo.

Y aquí viene la magia de VS Code, vamos a abrir una línea de comandos desde la opción Terminal > New Terminal, esto abre una consola integrada en nuestro editor y automáticamente activa el entorno virtual ejecutando el script de activación.
Del lado izquierdo visualizarás la barra de estado de VS Code indicando que estamos utilizando un entorno virtual.

Actualizando y utilizando pip

Por defecto Python ya cuenta con un conjunto de funcionalidades integradas listas para usar, que se encuentran agrupadas en módulos. De seguro has usado el módulo random para generar números aleatorios, pero que pasa con Django.

Ya que Django es un paquete que no se encuentra directamente dentro de Python tenemos que instalarlo de manera externa.

¿Cómo instalamos Django?

Para instalar Django necesitamos de un gestor de dependencias o en otras palabras de un instalador de paquetes, y el más popular en Python es PIP (Package Installer for Python) ya que viene integrado junto con Python en el momento de la instalación.

Si vienes de JavaScript de seguro conoces npm y se te hará muy familiar los comandos a la hora de instalar paquetes con pip.

Un paso adicional antes de empezar a instalar paquetes, es tener actualizado pip en nuestro entorno virtual, que si recuerdas ya se encuentra activado en la consola de VS Code, ejecuta el siguiente comando:



pip install --upgrade pip

Ahora procederemos a instalar Django en el entorno virtual:



pip install django

Puedes verificar que Django fue instalado con el siguiente comando:



pip freeze

Crear un proyecto de Django

Ahora que ya tenemos instalado Django tenemos disponible el comando django-admin que nos permitirá crear nuestro primer proyecto.

Vamos a la consola de VS Code con tu entorno virtual activado y ejecuta el siguiente comando:



django-admin startproject proyecto_django .

El punto (.) al final del comando indica que el proyecto será creado en la carpeta actual.

Creando archivos de configuración para cada entorno

En un entorno profesional de trabajo es ideal manejar un servidor diferente por cada etapa del proyecto, es decir, cuando realizamos cambios al código del proyecto, usamos un entorno de desarrollo, cuando el cliente prueba funcionalidades nuevas para aprobarlas, se usa un servidor de staging, y finalmente cuando la aplicación es accesible para todos, se usa un servidor de producción.

Es por ello importante manejar archivos de configuración diferentes por cada entorno, ya que esas configuraciones serán diferentes para cada servidor, por lo que sería tedioso manejar un solo archivo y estar cambiando a cada rato cuando nos cambiamos de entorno.

Django por defecto maneja toda la configuración del proyecto en un solo archivo (proyecto_django/settings.py), pero ahora queremos manejar múltiples archivos de configuración por cada entorno manejado.

Para ello vamos a agrupar todos esos archivos de configuración en un sola carpeta llamada settings, creamos la carpeta dentro de la subcarpeta proyecto_django y creamos la siguiente estructura de archivos:



proyecto_django/settings
├── __init__.py
├── base.py
├── local.py
└── production.py

Vamos a describir cada archivo de la carpeta settings:

__init__.py: Un archivo vacío que le dice a Python que esta carpeta se trata de un paquete.
base.py: Todas las configuraciones en común entre entornos.
local.py: Contiene todas las configuraciones de tu entorno local (que incluyen las de base.py).
production.py: Configuraciones para el entorno de producción.

¿Qué contenido tendrá base.py?

Todas las configuraciones que no cambien entre los distintos entornos manejados, estará dentro del archivo base.py. Como recomendación copia el contenido del archivo settings.py y pegalo en base.py luego ve identificando que configuraciones son distintas entre tus diferentes entornos.

Identificando configuraciones que cambien entre entornos

La primera configuración que podemos identificar es la siguiente:



# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

En un entorno local tener el modo DEBUG activado te facilitará visualizar una página detallada de errores a la hora de codear. En un entorno de producción no queremos mostrarle a nuestros usuarios esos errores detallados, ya que contiene datos sensibles del servidor, por lo que estaríamos expuestos a detalles de seguridad.

La variable de configuración ALLOWED_HOSTS es una lista de hosts/nombres de dominio que nuestro sitio de Django puede servir. Si la variable DEBUG es True y ALLOWED_HOSTS es una lista vacía se proporcionará acceso solamente a ['.localhost', '127.0.0.1', '[::1]'].

Por el momento copiamos esas dos variables de configuración y las pegamos en local.py y production.py, por ahora solamente cambiamos en el archivo production.py la variable DEBUG en False. Ya podemos eliminar esas dos variables de configuración en el archivo base.py.

local.py



# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

production.py



# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False

ALLOWED_HOSTS = []

Ahora tenemos la variable de configuración DATABASES que contiene las configuraciones para todas las bases de datos usadas con Django:



# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

En un entorno local nos interesa manejar datos de prueba para verificar el funcionamiento de la aplicación, Django trae por defecto la configuración con una base de datos SQLite, que no es más que un simple archivo donde son guardados los datos.

Para el entorno de producción, Django soporta múltiples motores de base de datos para usar, como MariaDB, MySQL, Oracle o PostgreSQL. El siguiente es un ejemplo para PostgreSQL (Recuerda tener instalado el driver correspondiente con el motor de base de datos):



DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Copia la variable de configuración DATABASES y pegalo en tu archivo local.py, para el caso de production.py puedes utilizar por ahora el ejemplo para PostgreSQL. Ya puedes eliminar la configuración para la variable DATABASES en el archivo base.py.

Por último tenemos la variable de configuración STATIC_URL que es la URL a usar para hacer referencia a los archivos estáticos, puede tener diferentes valores dependiendo del entorno, pero por ahora usaremos el mismo valor para los archivos local.py y production.py.

Ya para finalizar tenemos que importar todas las variables de configuración del archivo base.py a local.py y production.py:



from .base import *

Nuestros archivos de configuración se verán de la siguiente manera:

base.py



"""
Django settings for proyecto_django project.

Generated by 'django-admin startproject' using Django 3.2.6.

For more information on this file, see
https://docs.djangoproject.com/en/3.2/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.2/ref/settings/
"""

from pathlib import Path

# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'my-secret-key'


# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'proyecto_django.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'proyecto_django.wsgi.application'


# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field

DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

local.py



from .base import *

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []


# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/

STATIC_URL = '/static/'

production.py



from .base import *

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False

ALLOWED_HOSTS = []


# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/

STATIC_URL = '/static/'

Modularizando la variable INSTALLED_APPS

Dentro del archivo base.py te encontrarás con la variable de configuración INSTALLED_APPS que es una lista de todas las aplicaciones que están habilitadas para el proyecto. Django maneja el concepto de aplicación como un conjunto de funcionalidades únicas y que se pueden reutilizar en otros proyectos.

Si miras la lista verás que un proyecto de Django trae por defecto todo un conjunto de funcionalidades listas para usar, como el sitio de administración de Django, el sistema de autenticación, el manejo de sesiones, etc.

Todos estos paquetes pertenecen a Django, pero sorpresa, podemos instalar paquetes de terceros, o mejor aún crear nuestros propios paquetes. Una buena práctica es separar estos diferentes tipos de paquetes en distintas variables.

Para los paquetes de Django declaramos la variable DJANGO_APPS, para los paquetes de terceros la variable THIRD_PARTY_APPS y para paquetes propios la variable LOCAL_APPS, las variables se verán de la siguiente manera:



# Application definition

DJANGO_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

THIRD_PARTY_APPS = []

LOCAL_APPS = []

INSTALLED_APPS = DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS

Actualiza el valor por defecto de DJANGO_SETTINGS_MODULE

Ahora que cambiamos el archivo de configuración settings.py que trae Django por defecto a múltiples archivos de configuración por cada entorno, tenemos que actualizar los archivos asgi.py, wsgi.py y manage.py.

Cambiamos



os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'proyecto_django.settings')

por



os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'proyecto_django.settings.local')

Esto quiere decir que ahora Django utilizará el archivo de configuración local.py.

Para un entorno de producción tienes que configurar la variable de entorno DJANGO_SETTINGS_MODULE para apuntar hacia el archivo de configuración proyecto_django.settings.production

Creando la base de datos de desarrollo

Ya que se trata de un proyecto inicial de Django, por ahora no tenemos ningún modelo creado, pero tenemos los modelos que trae Django por defecto, ejecuta el siguiente comando para crear una base de datos de desarrollo:



python manage.py migrate

De inmediato visualizarás dentro de la subcarpeta proyecto_django un archivo db.sqlite3 en donde se guardarán los datos para el entorno local.

Mantener algunas configuraciones de manera secreta

En algunas variables de configuración tendrás valores que no vas a querer compartir o subir a tu repositorio por razones de seguridad o porque simplemente solo funcionarán para tu entorno de desarrollo, estas variables pueden ser SECRET_KEY que no debemos usar la misma para producción y para desarrollo, DATABASES si estas manejando de manera local una base de datos PostgreSQL, en donde tendrás que especificar nombre de usuario, contraseña del usuario, nombre de la base de datos, puerto, etc.

Estas son solo algunas variables que pueden cambiar sus valores y necesitas mantenerlas secretas, es decir, no darle seguimiento a través del sistema control de versiones, o en caso de que otras personas están colaborando en el proyecto y van a configurar su propio entorno de desarrollo.

Para ello vamos a instalar una librería con pip llamada Python Decouple que nos ayudará a separar esos valores en un archivo .env, ejecuta el siguiente comando en tu consola:



pip install python-decouple

Ahora crea un archivo .env en la raíz de tu proyecto con el siguiente contenido:



SECRET_KEY=my-secret-key
DB_NAME=django
DB_USER=root
DB_PASSWORD=
DB_HOST=127.0.0.1
DB_PORT=5432

El archivo .env no se agregará al historial de cambios en el sistema control de versiones, ya que en un paso anterior lo hemos agregado en el .gitignore

Necesitamos importar la librería en el archivo base.py:



from decouple import config

Cambia el valor de SECRET_KEY por lo siguiente:



SECRET_KEY = config('SECRET_KEY')

En caso de que quieras manejar un motor de base de datos diferente en tu entorno local, en lugar del archivo de SQLite que maneja Django por defecto, tendrás que configurar las variables correspondientes en tu archivo local.py:



DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': config('DB_NAME'),
        'USER': config('DB_USER'),
        'PASSWORD': config('DB_PASSWORD'),
        'HOST': config('DB_HOST'),
        'PORT': config('DB_PORT'),
    }
}

Recuerda cambiar a los valores correctos según tu entorno en el archivo .env.

Convirtiendo a otros tipos de datos

Todos los valores que se leen del archivo .env son manejados como una cadena de texto, pero en caso de que quieras configurar una variable como EMAIL_PORT, manejada por Django para el envió de correos, esta debe ser configurada como un entero, por lo que podemos pasarle el argumento cast a la función config() para transformar el valor de cadena como un número entero:



config('EMAIL_PORT', cast=int)

Manejando valores por defecto

Un argumento extra que le podemos pasar a la función config() es default, que definirá un valor por defecto en caso de que la variable de entorno no este definida en el archivo .env:



config('EMAIL_PORT', default=25, cast=int)

Ahora no es necesario que la variable de entorno EMAIL_PORT este definida en el archivo .env

Compartir las variables de entorno definidas para el proyecto

Seguramente te preguntarás porque vamos a compartir algo que al principio mencionamos que mantendríamos en secreto, pues no precisamente vamos a compartir los valores, sino, más bien las variables que necesita el proyecto para funcionar correctamente.

Si una persona se une al proyecto no sabrá como configurar y ejecutar la aplicación de manera correcta, por lo que debemos dejar un ejemplo de las variables que tiene que configurar. Para ello vamos a crear un archivo .env.example en la raíz del proyecto que contendrá datos de ejemplo, esto servirá como referencia para crear el archivo .env con los valores del entorno apropiado.

El archivo .env.example si se agregará al repositorio, ya que solo contendrá datos de ejemplo con las variables de entorno para crear el archivo .env, y recuerda cambiar los valores para que tu entorno funcione correctamente.

Creando nuestra primera app

Recuerdas que te había mencionado que podíamos crear nuestros propios paquetes, pues hemos llegado a ese momento.

Si ejecutamos el siguiente comando, Django va a crear una app en la raíz del proyecto:



python manage.py startapp home

Aunque esto es correcto, si el proyecto va creciendo y se van creando más apps, se tendrá en la raíz del proyecto una lista interminable de carpetas.

Entonces vamos a aplicar desde el inicio del proyecto buenas prácticas. Crea en la raíz del proyecto una carpeta llamada apps, aquí englobaremos todas las apps creadas.

Si ejecutaste el comando anterior recuerda eliminar la carpeta home de la raíz del proyecto.

Desde tu línea de comandos en VS Code y con tu entorno virtual activado, ingresa a la carpeta apps y ejecuta el siguiente comando:



cd apps
django-admin startapp home

Visualizarás que dentro de la carpeta apps se ha creado una subcarpeta home con la siguiente estructura:



apps
└── home
    ├── __init__.py
    ├── admin.py
    ├── apps.py
    ├── migrations
    │   └── __init__.py
    ├── models.py
    ├── tests.py
    └── views.py

Vamos a explicar rápidamente cada archivo:

views.py: Contiene la lógica o funcionalidad de la aplicación.
models.py: Contiene un conjunto de clases que definen la estructura de datos a utilizar por la aplicación.
migrations: Una carpeta que es usada por Django para manejar las versiones de la base de datos.
apps.py: Configuraciones propias de la aplicación
admin.py: Creación de la interfaz administrativa para el manejo de modelos.
tests.py: Creación de pruebas.

Creando nuestra primera vista

Modifica el archivo home/views.py para crear una vista que nos retorne un saludo como respuesta:



from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, Django!")

Ahora crea un archivo home/urls.py para definir las diferentes rutas asociadas a las vistas:



from django.urls import path
from . import views

urlpatterns = [
    path("", views.index, name="home"),
]

Dentro de la subcarpeta proyecto_django hay un archivo urls.py que es el encargado de manejar el enrutamiento dentro de la aplicación. Una buena práctica es crear un archivo urls.py dentro de cada app, con la idea de modularizar las rutas de cada aplicación.

En el archivo proyecto_django/urls.py tienen que incluirse las rutas de cada app:



from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path("", include("apps.home.urls")),
    path('admin/', admin.site.urls)
]

Debugging con Django

Para probar nuestra aplicación simplemente ejecutamos el siguiente comando:



python manage.py runserver

Abre un navegador y visita http://127.0.0.1:8000 para ver una página que renderiza "Hello, Django!".

Seguramente te estarás preguntando si existe una manera más fácil de ejecutar el servidor de desarrollo, y has llegado a la parte indicada.

Vamos a crear algo genial en VS Code que ayudará tanto a correr la aplicación como para realizar debugging.

Cambia el modo Run and Debug en el lado izquierdo de tu barra de actividad y verás el mensaje "To customize Run and Debug create a launch.json file", si das clic en el enlace create a launch.json file esto va a crear un archivo launch.json que contendrá las configuraciones de depuración.

Selecciona el enlace y VS Code te solicitará una configuración para depuración. Selecciona Django y automáticamente VS Code crea el archivo launch.json con las configuraciones para ejecutar la aplicación de Django.

Visualiza la configuración que se genero:



{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Django",
            "type": "python",
            "request": "launch",
            "program": "${workspaceFolder}/manage.py",
            "args": [
                "runserver"
            ],
            "django": true
        }
    ]
}

Prácticamente esta configuración dice que ejecute "${workspaceFolder}/manage.py" con los argumentos en la lista args.

Vamos ahora a probar la configuración, selecciona la opción Run > Start Debugging, o selecciona la flecha verde para ejecutar el servidor de desarrollo:

Abre el navegador, visita http://127.0.0.1:8000 y verifica que la aplicación se ejecuta correctamente. De ahora en adelante puedes usar Run > Start Debugging en cualquier momento para probar la aplicación.

Y hemos llegado al final de este post, cuéntame en los comentarios que te ha parecido, si tienes dudas o sugerencias con respecto al contenido, estoy seguro que aprenderemos juntos, ya que la mejor manera de aprender es enseñando.

Por último dime que te gustaría ver en próximos posts y házmelo saber a través de mis redes sociales.

Sígueme en Facebook
Sígueme en Twitter