Páginas

martes, 15 de junio de 2021

Números primos en Flask

Disponemos de varios métodos para generar números primos en Python y deseamos crear una página web con Flask para mostrarlos.

Los números primos se pueden ver en la siguiente entrada del blog.

Números primos en Python

Elegimos el último método que contiene el código más breve y montamos con él un fichero llamado genera.py.

genera.py

def generaPrimos(n):
 lista=[i for i in range(2,n+1)]
 for i, k in enumerate(lista):
  if i<=int(n**.5):
   for j in lista[i+1:]:
    if j % k == 0:
     lista.remove(j)
 return lista

Creamos el archivo app.py que lanza la aplicación y el servidor Flask.

app.py
from genera import generaPrimos
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def index():
 n=1000
 titulo="Números primos hasta " + '{:,}'.format(n).replace(',', '.')
 return render_template("index.html", titulo=titulo, lista=generaPrimos(n))

if __name__ == "__main__":
 app.run(debug=True)

Veamos la estructura de ficheros.


Los archivos style.css y main.js están vacíos. El archivo favicon.ico es un icono muy pequeñito creado en la siguiente web, aunque pudiera ser cualquier otro fichero de imagen, tipo icono, muy pequeño.


Veamos el archivo index.html.

index.html
<!DOCTYPE html>
<html>
 <head>
  <meta charset="utf-8">
  <title>Home</title>
  <link rel="shortcut icon" href="../static/imgs/favicon.ico">
 </head>
 <body>
  <h1>{{ titulo }}</h1>
  <ul>
  {% for value in lista %}
  <li>{{ value }}</li>
  {% endfor %}
  <ul>
 </body>
</html>

Se lanza la aplicación app.py con python y así podremos ver la página en local.



domingo, 13 de junio de 2021

Maquina de Galton en Python

 Podemos ver una entrada que habla sobre el tema desarrollada en Excel.

Máquina de Galton en Excel

En esta ocasión vamos a crear un procedimiento en Python.


import numpy as np
import matplotlib.pyplot as plt
from random import randint
levels = int(input("How many levels do you want?(min 1/ 20 by default) ") or 20)
if levels >= 1:
  lanes = [0]*(levels)
else:
  print("The value of levels can't be lower than 1.")
  exit()
for h in range((levels)**2*100):
  stored = -1
  for j in range(levels):
    stored += randint(0, 1)
  lanes[stored] += 1
print((levels)**2*100, "balls were used in totall")
print(lanes)
X = np.arange(-((len(lanes)/2)-.5), (len(lanes)/2)+.5)
plt.suptitle('Galton Board')
plt.bar(X + 0.00, lanes, width=0.25)
plt.show()
plt.savefig("BellCurve.png")

La clave del algoritmo está en la línea:

stored += randint(0, 1)

Esta línea lo que hace es añadir un 1 o un 0 con una probabilidad de ½. Esto representa lo que hacen las bolas al tropezar con uno de los pivotes, donde pueden ir a la derecha o a la izquierda con una probabilidad del 50%. Si una bola baja 10 niveles y va la derecha en seis ocasiones y a la izquierda en cuatro ocasiones, el valor de la variable stored sería 6.

sábado, 12 de junio de 2021

Hola mundo con Node JS y Express

Vamos a crear una página web con un sencillo Hello World programado en Node.JS usando el framework Express. Lo podremos ver en local en nuestra página web de localhost.


Paso 1

Instalamos Node.JS e instalamos el gestor de paquetes npm.

sudo apt install nodejs
sudo apt install npm



Paso 2

Vamos a Documents y creamos un par de carpetas, una para los proyectos Node y otra para el proyecto actual de Hola Mundo.

mkdir node && cd $_
mkdir holamundo && cd "$_"
Con $_ repetimos la última parte del comandando anterior.
Si esa última parte lleva espacios se debe usar entre comillas "$_".
El operador $_ se puede sustituir por !#:1

Paso 3

Instalamos el framework Express que nos hará más sencilla la programación en Node.JS.
También vamos a instalar nodemon que nos ayudará a desarrollar puesto que la modificaciones de código que hagamos se irán mostrando automáticamente en la página que estamos creando.

npm init
npm install express
npm install nodemon

Paso 4

Desde la terminal, estando en el directorio holamundo tecleamos code . (el punto es importante) y nos llevará a nuestro editor por defecto, que en nuestro caso es Visual Studio Code.

Estando en Visual Studio Code creamos el archivo index.js


const express = require('express')
const app = express()
const port = 8080

app.get('/', (_req, res) => {
 res.send('Hello World!')
})

app.listen(port, () => {
 console.log(`Example app listening at http://localhost:${port}`)
})

Paso 5

En el archivo package.json se ha creado un archivo JSON con las variables de entorno y otras características de nuestro proyecto. En la parte de Scripts se añade un script llamado dev, pero el nombre lo elegimos nosotros.
Se pone una coma y se añade el script.

{
 "name": "helloworld",
 "version": "1.0.0",
 "description": "Esto es un hola mundo",
 "main": "index.js",
 "scripts": {
  "test": "echo \"Error: no test specified\" && exit 1",
  "dev": "nodemon index"
 },
 "author": "apa",
 "license": "ISC",
 "dependencies": {
  "express": "^4.17.1",
  "nodemon": "^2.0.7"
 }
}

Hemos añadido la línea:

"dev": "nodemon index" 

y hemos añadido también la coma previa a esta línea.

Paso 6

Corremos el proyecto con:

npm run dev
Ya tenemos corriendo el proyecto en local, en localhost.





jueves, 10 de junio de 2021

Flask en PythonAnywhere con despliegue continuo usando GitHub

Este es el tercer, y ultimo, artículo en una serie de tres que muestran cómo disponer de una aplicación sencilla de Flask en PyuthonAnywhere.

  1. Hola Mundo en PythonAnywhere con Flask
  2. PythonAnywhere subiendo una aplicación Flask desde GitHub
  3. Flask en PythonAnywhere con despliegue continuo usando GitHub ← (es el post en el que estamos)


Cambiando nombres seguiremos los pasos de la entrada:

PythonAnywhere subiendo una aplicación Flask desde GitHub

Lo que haremos en este caso es comenzar con una cuenta nueva en PyhthonAnywhere denominada universo que nos permitirá desplegar la página web:

https://universo.pythonanywhere.com

El objetivo es emplear una cuenta gratuita de PythonAnywhere y desplegar una aplicación web en Flask manteniendo nuestro repositorio en GitHub, usando despliegue continuo.

El flujo de trabajo será el siguiente.

Visual Studio Code (local ) GitHub  PythonAnywhere

Referencias

Paso 1

Vamos a crear un nuevo repositorio en GitHub con un 'Hola mundo' en Flask.

Se llamará flaskanywhere.

https://github.com/financieras/flaskanywhere

Si al crear el repositorio no se indica que se añadirán los ficheros readme, licencia y gitignore, GitHub nos ofrece una pantalla con ayuda para comenzar a trabajar con git. En esa página vemos una serie de instrucciones de git para subir los archivos.


Reproducimos el código sugerido en la imagen anterior.

  • Crear un nuevo repositorio en la línea de comandos.
echo "# flaskanywhere" >> README.md
git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/financieras/flaskanywhere.git
git push -u origin main
  • Enviar un repositorio existente desde la línea de comandos.
git remote add origin https://github.com/financieras/flaskanywhere.git
git branch -M main
git push -u origin main

Paso 2

Podemos "enviar" (push) nuestro código a GitHub, y luego "tirarlo" (pull) a PythonAnywhere, o enviarlo desde PythonAnywhere hacia GitHub.

En PythonAnywhere, usaremos una Consola Bash y así podremos acceder a git y clonar nuestro repositorio, pudiendo luego hacer push (enviar, empujar) y pull (tirar, traer).

Veamos el código que queremos subir a GitHub.

El archivo se llamará app.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from flask import Flask, request
from flask.wrappers import Response
import git

app = Flask(__name__)

@app.route('/git_update', methods=['POST'])
def git_update():
  repo = git.Repo('./flaskanywhere')
  origin = repo.remotes.origin
  repo.create_head('main', 
  origin.refs.main).set_tracking_branch(origin.refs.main).checkout()
  origin.pull()
  return '', 200

@app.route('/')
def hello():
  return '<h1>Hello from Flask</h1><p>Continuous Deployment.</p>'

En la línea

  repo = git.Repo('./flaskanywhere')

no olvide sustituir flaskanywhere por el nombre de su repositorio.

Crearemos un entorno virtual.

El archivo anterior app.py ha sido creado en VSCode y subido a GitHub. Para ello, cambiando los nombres necesarios, seguiremos los pasos de la entrada:


En PythonAnywhere nuestro nombre de dominio que estaba disponible es universo.

Paso 3

Creamos la cuenta universo en PythonAnywhere.














Activamos el protocolo SSH para tener página https.




Veamos a seleccionar la:
 WSGI configuration file: /var/www/universo_pythonanywhere_com_wsgi.py


Vemos que la ruta (path) está correcta y que el nombre de la aplicación es app.



Clonamos nuestro repositorio desde una terminal Bash, desde PythonAnywhere

git clone https://github.com/financieras/flaskanywhere.git
Cambiamos la ruta Source code añadiendo al final flaskanywhere.


Editamos el archivo:

WSGI configuration file:/var/www/universo_pythonanywhere_com_wsgi.py

para que en la línea 11 contenga la ruta actualizada.

project_home = '/home/universo/flaskanywhere'


Recargamos, pulsando el botón verde, y mostramos la página.



Hagamos un ligero cambio en nuestro código de la aplicación Flask. Pondremos el texto en español.




Pulsando el botón verde de recarga y actualizando la página ya vemos los cambios.



En este momento ya hemos conseguido automatizar el proceso más allá de lo que quedó descrito en el post anterior, ya que gracias al Webhook y al nuevo código del archivo app.py ya hemos conseguido despliegue contínuo.

Ahora nos gustaría que no fuera necesario recargar la página pulsando el botón verde, y que la página se recargara sola al subir los cambios desde nuestro Visual Studio Code.

Recarga automática

En la consola Bash de PythonAnywhere introducimos los siguientes comandos estando en el directorio correspondiente.

En nuestro caso, estamos en flaskanywhere/.git/hooks


cat>post-merge
touch /var/www/universo_pythonanywhere_com_wsgi.py

Después de introducir este código en la consola pulsamos Control+C

Podemos consultar si se ha creado correctamente el archivo post-merge.

cat post-merge

Otra forma de consultarlo consiste en ir a la página de PythonAnywhere y mirar el archivo con post-merge que estará en la ruta que se muestra en la siguiente imagen.



La siguiente imagen muestra los comando introducidos en la consola Bash de PythonAnywhere.


El último comando da permisos de ejecución al archivo creado.
chmod +x post-merge

Finalmente hacemos algún cambio más en en código Flask, en nuestro Visual Studio Code. Se suben los cambios a GitHub y sin necesidad de hacer nada más ya tendremos nuestras modificaciones en la web. Simplemente actualizando la página ya veremos los cambios.



En el artículo de Medium que hemos utilizado también se habla de la seguridad, por si quieres implementarla, si bien, al tratarse de una cuenta gratuita en PythonAnywhere ya existen sistemas que interrumpirán el servicio de la página en caso de sobrepasarse el uso de la CPU.

¿Cuál es el siguiente paso?

Lo siguiente es poder desarrollar páginas web en Flask más complejas usando Templates y usando Jinja2.

domingo, 6 de junio de 2021

Hola mundo en JAVA

Referencias

Estamos siguiendo el curso siguienete aunque es de 2014 y algunas cosas han cambiado con las nuevas versiones.

Curso de Java desde 0


Otros recursos.

Curso de JAVA básico

 

Actualizamos Ubuntu

Estamos en Linux, concretamente Ubuntu 20.04.

Primero hacemos un update y un upgrade.

sudo apt update -y && sudo apt full-upgrade -y && sudo apt autoremove -y && sudo apt clean -y && sudo apt autoclean -y 

Instalamos JAVA

Antes de ello miramos a ver si ya lo tenemos instalado.

java --version


Con la versión 11 del JDK suele ser suficiente en la mayoría de los casos. La versión 11 es una versión LTS (Long Term Support).

Actualmente va por la versión 15.

En caso de necesitar instalarlo o necesitar la versión 14.

sudo apt install openjdk-14-jdk

Instalamos Eclipse

Descargamos Eclipse de su página principal https://www.eclipse.org/downloads

Vamos a la carpeta Downloads donde se ha descargado y en consola tecleamos.

sudo tar -xf eclipse-inst-jre-linux64.tar.gz -C /opt

Vamos a la carpeta:

cd /opt/eclipse-installer

Instalamos eclipse:

sudo ./eclipse-inst

Programa de Instalación

Se abrirá el programa de instalación. Cuando nos pregunte por el espacio de trabajo nos sugerirá Eclipse-workspace. Podemos navegar por nuestro disco duro y elegir otro, por ejemplo en Documents/cursoJava y marcar el tick para que lo recuerde.

Programar el Hola Mundo

Creamos un nuevo proyecto con File/New/Java Project


El nombre del proyecto será HolaMundo (siempre sin espacios).
Elegimos el JRE 11.
Pulsamos Next.


Si está marcado, desmarcamos la opción "Create module-info.java file".
Pulsamos Finish.

Se ha creado la carpeta src, abreviatura de source code.


Creamos una clase. Esto se puede lograr de varias formas:

  • Creamos una nueva Clase en File/New/Class
  • Pulsando con el botón derecho sobre src y eligiendo New/Class
  • Con el icono que hay más a la izquierda, eligiendo Class

El nombre de la clase, por convenio, siempre va con la primera letra en mayúscula y debe ir sin espacios. Hemos elegido como nombre de clase Hola.

//Creación de un Hola Mundo
public class Hola {
     public static void main(String[] args) {
          System.out.println("Hola Mundo");
     }
}


Grabamos con Control + s

Ejecutamos pulsando el icono verde con la flechita típica de Play. Se abrirá una consola donde podremos ver la ejecución del programa.

También podremos abrir una consola en Window/Show View/Console.

jueves, 3 de junio de 2021

PythonAnywhere subiendo una aplicación Flask desde GitHub

Este es el segundo artículo en una serie de tres que muestran cómo disponer de una aplicación sencilla de Flask en PyuthonAnywhere.

  1. Hola Mundo en PythonAnywhere con Flask
  2. PythonAnywhere subiendo una aplicación Flask desde GitHub ← (es el post en el que estamos)
  3. Flask en PythonAnywhere con despliegue continuo usando GitHub

Podemos seguir una serie de pasos para lograr nuestro objetivo.

1. Creamos el repositorio

Lo primero será crear el repositorio en GitHub donde subiremos el código.

En GitHub existe una página que nos explica cómo crear nuestro repositorio.
Pulsamos sobre el botón New.


Creamos el nuevo repositorio.



Hemos llamado a nuestro repositorio flaskmasterfinan y se encuentra en esta dirección:

Al crear el repositorio nuevo hemos creado también un readme donde podremos explicar brevemente el proyecto.




2. Clonamos el repositorio en local

Suponemos que en nuestro PC tenemos ya instalado git.

Abriendo una terminal en local procedemos a clonar nuestro repositorio. Nos situamos en la carpeta donde tenemos el resto de repositorios en mi caso pyApa que está en Documents.

git clone https://github.com/financieras/flaskmasterfinan.git


La dirección del repositorio acaba en .git y se puede tomar del botón verde Code que muestra la siguiente imagen.


Ya tenemos todos los archivos clonados en local, en una carpeta con el mismo nombre que el repositorio, en nuestro PC.

3. Creamos un entorno virtual

Dentro de la carpeta vamos a crear un entorno virtual para Python. Para ello en la consola dentro de la carpeta del repositorio ejecutaremos una serie de comandos.

Instalar el entorno virtual (virtual environment). Si usamos Python 3 viene con venv que es la nueva forma de instalar el entorno virtual. Si usas Python 2 debes usar el sistema antiguo con virtualenv. En nuestro caso como usamos Python3, usaremos venv que es más sencillo de instalar, demás es el que se recomienda en la instalación de Flask (Instalación 2.0.x).

Actualmente no es necesario instalar virtualenv ya que existe venv que es el que instalamos en nuestro Ubuntu así:

sudo apt install python3-venv
python3 -m venv venv

La segunda venv es el nombre del entorno virtual, podemos asignar el nombre que queramos.


Activación del entorno virtual

El entorno virtual se activa así:

. venv/bin/activate




Dentro del entorno virtual no es necesario poner python3, si ponemos simplemente python ya se sabe que es la versión 3, tal y como se ve en la imagen anterior.

Instalar Flask


Estando dentro del entorno virtual instalar Flask, así:
pip install Flask

Ya tenemos instalada la última versión de Flask, que en este momento es la 2.0.1.


Desactivación del entorno virtual

Veamos cómo desactivar el entorno virtual. El entorno virtual se desactiva así:
deactivate


Para seguir con nuestro proyecto entraremos nuevamente en el entorno virtual.

4. El código de la aplicación

Dentro de la página de Flask existe una guía rápida para comenzar a crear nuestra aplicación básica, un 'Hola mundo'.


Ahora que tenemos montado nuestro entorno virtual en local podemos abrir Visual Studio Code y desarrollar la aplicación.

Para abrir VSCode podemos, estando en la terminal, en el entorno virtual, escribir:

code .

Poner el punto es importante.



Automáticamente se abrirá nuestro Visual Studio Code.



Creamos el archivo app.py

Comenzamos creando una aplicación sencilla de Flask usando el siguiente código.

app.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
    return '<p>Hello World</p>'

Creamos un .gitignore

Si miramos nuestro VSCode veremos que existen varios cientos de archivos que deben subirse a GitHub, cuando en realidad únicamente hemos creado el archivo app.py. Lo que está sucediendo es que ha detectado todos los archivos necesarios para montar el entorno virtual y si no hacemos nada los subirá a GitHub al hacer un push.



Para evitar que esto suceda crearemos un archivo .gitignore donde anotamos todos los archivos y carpetas que deseamos que no se suban a GitHub.

Ahora queremos subir el codigo del archivo app.py a GitHub pero no los archivos que nos ha generado crear el entorno virtual. Lo solucionamos creando otro archivo llamado .gitignore el punto es importante.

Dentro de él ponemos el nombre de los archivos que no queremos que se suban a nuestro repositorio.

Creamos el archivo .gitignore en la página:


indicando en el formulario los términos: linux, venv, Flask.

Se obtiene esta página:




Solucionado, ahora únicamente VSCode avisa de dos archivos que se han de subir, que son nuestro app.py y el propio .gitignore.

Creamos un requirements.txt

Una de las ventajas del entorno virtual es que nos puede generar un archivo con todas las dependencias que tiene nuestro proyecto, en este caso Flask, usando el comando:

pip freeze>requirements.txt




Como hemos clonado el repositorio, está conectado con GitHub lo que significa que podemos hacer un commit directamente. 

Ya tenemos tres archivos pendientes de subir a GitHub y los subimos abriendo una terminal en VSCode y ejecutando las siguientes líneas en la consola bash.
git add --all
git commit -m "Primera version funcional"
git push


Ya tenemos subida nuestra aplicación básica de Flask a GitHub.

5. La cuenta de PythonAnywhere


Creamos una cuenta gratuita en PyhtonAnyWhere

Nos pedirá rellenar una dirección de correo electrónico y un nombre de usuario que esté disponible. Es importante elegir ese nombre para que sea de nuestro gusto ya que luego se usará en la dirección web. En nuestro caso hemos elegido como nombre de usuario masterfinan que estaba disponible y nadie lo tenía en uso. Esto supone que luego la dirección web que nos den será:


Añadimos una aplicación web

 En la pestaña web veremos un botón que nos invita a añadir una aplicación web.

Pulsamos sobre el botón 'Add a new web app'.




Elegir la última versión de Flask disponible.


Cambiamos el Path por el siguiente.

/home/masterfinan/app.py

donde
  • masterfinan es el usuario de PythoAnywhere que hemos creado
  • app.py es el nombre de la aplicación de Flask que hemos creado



Ahora ya podemos ver la pestaña Web de otra forma.






En este momento ya tenemos desplegada una página web, aunque no se trata de la que hemos programado.

Observamos que arriba pone 'Not secure' esto se debe a que es una página de tipo http y no https. Para conseguir que sea de tipo https debemos activar en la seguridad esta opción.


Ahora al solicitar la página web con https veremos que ya no vemos la advertencia de seguridad.



Configuración de la página web servida


Dentro de la pestaña Web tenemos una línea que dice 'WSGI configuration file: /var/www/masterfinan_pythonanywhere_com_wsgi.py'
Pulsamos sobre el enlace de esa ruta y nos lleva al siguiente archivo.




Vemos que la ruta (path) está correcta y que el nombre de la aplicación es app.

Todo esto está correcto, y por el contrario si recargamos la página esta no se actualiza con la web que nosotros hemos programado, ¿a qué se debe esto?

Podemos comprobar en la pestaña 'Files' los archivos disponibles en este momento.




Si editamos el actual archivo app.py vemos el siguiente código.



Esto explica el motivo por el que no estamos viendo nuestra página de Flask sino una página de Flask que nos proporciona PythonAnywhere por defecto.

La razón por la que no vemos nuestra página se debe a que aún no la hemos subido a PythonAnywhere, de momento solo la tenemos subida a GitHub.

6. Clonado desde PythoAnywhere

Para solucionar el inconveniente anterior lo que haremos es clonar el proyecto desde PythonAnywhere usando la terminal bash que nos proporcionan.

Abrimos una consola bash en PythonAnywhere

Vamos a la pestaña 'Consoles'.




Abrimos una consola Bash.


Miramos los archivos que tenemos.



Clonamos nuestro repositorio

git clone https://github.com/financieras/flaskmasterfinan.git


7. Configuración ruta Web

Source code

Vamos a la pestaña Web y miramos en 'Source code' y cambiamos el path para que sea:

/home/masterfinan/flaskmasterfinan

Observe que hemos añadido al final la carpeta flaskmasterfinan.


WSGI configuration file

Entramos dentro del archivo:
/var/www/masterfinan_pythonanywhere_com_wsgi.py





Editamos el archivo para que contenga en la línea 11 la ruta de la carpeta del repositorio:

project_home = '/home/masterfinan/flaskmasterfinan'


Observe que hemos añadido al final la carpeta flaskmasterfinan con el nombre de nuestro repositorio que se ha creado al hacer el clonado.

En la línea 16 aparece dos veces la palabra app, veamos su significado.
  1. Primer app. Hace referencia al nombre de nuestro archivo app.py que hemos subido al hacer el clonado. Si nuestro archivo no se llamara app.py deberíamos poner aquí el nombre que hubieramos dado a nuestro archivo, sin poner la extensión .py.
  2. Segundo app. Hace referencia al objeto app = Flask(__name__) que aparece en la línea 5 de nuestro archivo app.py. Si el objeto se hubiera llamado de otra forma deberíamos indicar ese nombre en nuestro fichero de configuración WSGI.

8. Recargar y mostrar la página 


En la pestaña Web pulsamos el botón verde denominado 'Reload'.


Finalmente, pulsamos sobre el enlace que apunta a nuestra página:






¡Lo hemos conseguido!

Ya está disponible nuestra página web básica programada en Flask.

Truco

Para recargar una página web sin memoria cache pulsamos simultáneamente las dos teclas: 
Control + F5

9. Modificando la Web

¿Qué hacer si queremos modificar nuestra página web?

Vamos a realizar algún pequeño cambio en nuestro código, en local, en nuestro Visual Studio Code, cambiando ligeramente lo que vamos a mostrar en página web.

Editamos el archivo app.py

Modificamos ligeramente nuestro código.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
  return '<h1>Hola mundo</h1><p>Desde Flask</p>'
Hemos cambiado únicamente la última línea de código.


Subinos el cambio a GitHub

Lo subimos abriendo una terminal en VSCode y ejecutando las siguientes líneas en la consola bash. Tenemos que estar metidos en el entorno virtual.
git add --all
git commit -m "Cambiando el h1 y el p"
git push


Ahora los cambios ha llegado hasta GitHub pero aún no han llegado hasta PythonAnywhere.

Actualizamos los cambios en PythonAnyWhere

Para llevar los cambios desde GitHub, nuestra nube, hasta PythonAnywhere debemos usar la consola bash de éste y hacer un git pull.

git pull


Ya han llegado las modificaciones a PythoAnywhere.


Recargamos la página


Desde la pestaña Web puedes pulsar el botón verde de 'Reload' para recargar la página o puede que esto no sea necesario y la página web se sirva ya con las actualizaciones nada más recargarla.


Ya hemos completado el proceso. Hemos conseguido subir una aplicación sencilla programada en Flask desde nuestro Visual Studio Code, en local, hasta GitHub y finalmente desplegada en PythonAnywhere.

¿Cuál sería el siguiente paso? 

Nos gustaría que se pudiera hacer despliegue contínuo (continuous deployment) de forma que cambiando nuestra aplicación en Visual Studio Code se subiera directamente a PythonAnywhere y se mostrará en página web sin necesidad de realizar tantos pasos. Esto lo atacaremos en un post posterior. Poco a poco y siempre avanzando.