Saul  Alaniz

Saul Alaniz

1642063100

Comparando Deta Con Heroku Para Encontrar El Mejor Proveedor De Nube

La velocidad, la escalabilidad, el costo y la seguridad deben tenerse en cuenta al elegir un proveedor de servicios en la nube, ya que estas variables tienen un gran impacto en el éxito de su aplicación. Como resultado, es fundamental que haga un gran esfuerzo para determinar cuál es el mejor para usted.

En esta publicación, compararemos uno de los proveedores de servicios en la nube más populares, Heroku, con una alternativa relativamente nueva y totalmente gratuita, Deta. Exploraremos los servicios y las funciones que ofrecen ambas plataformas, su modelo de precios y su experiencia de desarrollador, es decir, la experiencia de hospedar una aplicación en estas plataformas.

¿Qué es Heroku?

Heroku es una plataforma en la nube como servicio (PaaS) fundada inicialmente por James Lindenbaum, Adam Wiggins y Orion Henry en 2017. Al principio, la plataforma se desarrolló solo para admitir proyectos creados con el lenguaje de programación Ruby, pero desde su adquisición por parte de Salesforce en 2010, la plataforma agregó soporte para múltiples lenguajes de programación, incluidos Java, Node.js, Scala, Clojure, Python, PHP y Go.

Características de Heroku

Heroku proporciona una variedad de herramientas y servicios para escalar e implementar fácilmente su aplicación. Algunos de estos incluyen:

Dynos

Casi todos los proveedores de servicios en la nube tienen un nombre único para su contenedor en la nube; El de Heroku es Dyno.

Dynos son los componentes fundamentales de cualquier aplicación de Heroku. Son contenedores Linux virtuales segregados que proporcionan todos los recursos de CPU, memoria y sistema operativo necesarios para ejecutar su aplicación.

Heroku también elimina el estrés de configurar recursos de hardware y máquinas virtuales para sus aplicaciones. En lugar de tener que preocuparse por la administración del hardware, simplemente puede publicar su aplicación en Heroku y la plataforma empaquetará todo el código y las dependencias de su aplicación en dynos.

Complementos

Heroku también le permite ampliar su proyecto con una variedad de complementos, que son servicios en la nube adicionales proporcionados por Heroku y desarrolladores externos para agregar más funcionalidades a su aplicación, como almacenamiento en caché, almacenamiento de datos (incluida la compatibilidad con Postgres, MongoDB y MySQL, entre otros), programación de eventos, registro y muchos otros.

Experiencia operacional

Otra característica intrigante que ofrece Heroku es la plataforma de experiencia operativa, que le permite concentrarse en mantener la confiabilidad de su aplicación mientras ofrece una excelente experiencia de usuario.

Esta plataforma ayuda a monitorear el estado de su aplicación, verificar su capacidad de respuesta y generar alertas proactivas sobre fallas en las solicitudes, incluso antes de que los usuarios las vean.

Precios

Heroku ofrece un generoso plan de dinamómetro gratuito, que incluye un dominio personalizado y una provisión gratuita de 512 MB de RAM. Sin embargo, su aplicación se suspenderá después de 30 minutos de inactividad. Esto significa que si no se envía una solicitud a su aplicación o no se visita su URL cada 30 minutos, la aplicación se suspenderá y la siguiente solicitud tardará hasta 10 segundos en cargarse.

Cualquier otro plan varía de $7 a más de $500 por banco de pruebas por mes, según los requisitos de su proyecto. Para obtener más información, consulte su página de precios .

Experiencia de desarrollador

El proceso de alojar su aplicación en Heroku es bastante simple. Una opción es configurar una canalización de CI/CD con Heroku y sus plataformas de desarrollo de proyectos, como GitHub o GitLab; otra opción es usar la CLI de Heroku , que es una forma aún más rápida de crear nuevos proyectos y administrar todos sus proyectos anteriores directamente desde su línea de comandos.

Con la CLI de Heroku, también puede simplemente buscar y agregar cualquiera de los complementos disponibles en su mercado a su proyecto, e incluso probar su proyecto localmente antes de implementarlo para el acceso público.

¿Qué es Deta?

Deta, "la nube para hacedores y soñadores", como se menciona en su página de inicio, es un proveedor de servicios en la nube relativamente nuevo y totalmente gratuito. Ofrece una interfaz amigable para desarrolladores que le permite implementar su programa en la nube en cuestión de segundos. Aunque la plataforma actualmente solo admite el alojamiento de proyectos Node.js y Python, la compatibilidad con lenguajes de programación adicionales en el futuro no será sorprendente.

Características

Deta Micros

Las aplicaciones alojadas en Deta, como Dyno de Heroku, se llaman micros; esta es una máquina virtual Linux en espacio aislado con más de 128 MB de RAM para cada ejecución de proceso, así como un sistema de archivos de solo lectura con hasta 512 MB de espacio de almacenamiento.

A diferencia de Heroku, que solo le permite ejecutar hasta dos dinamómetros gratuitos, puede crear una cantidad ilimitada de micros en Deta. Sin embargo, el tamaño del código fuente de su aplicación y sus dependencias no pueden exceder los 250 MB.

Actualmente, Micros solo es compatible con Node.js y Python. También vale la pena señalar que las versiones anteriores de ambos idiomas no son compatibles; esto puede cambiar en el futuro, pero actualmente se admiten las siguientes versiones:

  • Nodos: 12.x, 14.x
  • Pitón: 3.7, 3.8, 3.9

Base de datos

Deta no está configurado para operar con bases de datos relacionales como Postgres o MySQL, por lo que el equipo desarrolló su propia base de datos NoSQL segura diseñada específicamente para aplicaciones alojadas en su plataforma.

Deta Base es una base de datos NoSQL rápida y escalable que prioriza la comodidad del usuario final. Tiene una interfaz de usuario y un SDK que le permite administrar y consultar registros en su base de datos. La base de datos está disponible como Javascript, Python y Go SDK, y la sintaxis es bastante simple. Aquí hay un ejemplo de cómo insertar y eliminar registros de la base de datos:

const { Deta } = require('deta');

// Project key retrieved from deta dashboard
const deta = Deta('your-project-key'); 

// Connect to or create a new 'users' database.
const users = deta.Base('users'); 

// Add new user to the database.
users.put({name: "Elijah", state: 'Lagos'})

// delete user with key 'one'
const res = await db.delete("one")

Unidad de datos

Deta Drive, que es una solución de almacenamiento de archivos segura y escalable, es otro servicio que ofrece la plataforma. Es bastante similar a Deta Base, con la excepción de que Deta Drive se enfoca en la administración de archivos/activos, como imágenes, videos y otros tipos de medios, mientras que Deta Base se enfoca en la administración de datos. Todas las cuentas están limitadas a 10 GB de almacenamiento, que es una oferta bastante generosa teniendo en cuenta que es gratis, y todos los archivos almacenados en el disco se pueden administrar directamente desde su tablero o mediante programación a través de su SDK.

Precios

A diferencia de Heroku, Deta ofrece todos sus servicios de forma gratuita, y no es necesario que proporcione ningún detalle de tarjeta de crédito u otra información de pago confidencial para comenzar.

Experiencia del desarrollador

Deta, como Heroku, tiene su CLI integrada para administrar todos sus proyectos existentes o crear otros nuevos. A diferencia de Heroku, Deta actualmente no es compatible con CI/CD, lo que significa que no puede sincronizar su proyecto de GitHub o GitLab con Deta para reflejar los nuevos cambios a medida que se envían.

Pensamientos finales

A lo largo de este artículo, hemos comparado a Heroku , uno de los proveedores de servicios en la nube más populares, con Deta, una opción nueva y completamente gratuita. Ambas plataformas brindan excelentes servicios.

Sin embargo, por el momento, Deta es más rápido para poner las cosas en marcha, mientras que Heroku debería considerarse para aplicaciones empresariales. Además, debido a que Deta aún es relativamente joven, deberíamos esperar muchas actualizaciones interesantes en el futuro.

Enlace: https://blog.logrocket.com/deta-vs-heroku-finding-better-cloud-provider/

#heroku  #deta 

Comparando Deta Con Heroku Para Encontrar El Mejor Proveedor De Nube

DetaとHerokuを比較して、より優れたクラウドプロバイダーを見つける

クラウドサービスプロバイダーを選択するときは、速度、スケーラビリティ、コスト、およびセキュリティをすべて考慮する必要があります。これらの変数は、アプリケーションの成功に大きな影響を与えるためです。結果として、どれが自分に最適かを判断するために多くの努力を払うことが重要です。

この投稿では、最も人気のあるクラウドサービスプロバイダーの1つであるHerokuを、比較的新しく完全に無料の代替手段であるDetaと比較します。両方のプラットフォームが提供するサービスと機能、価格設定モデル、および開発者の経験、つまり、これらのプラットフォームでアプリケーションをホストする経験を調査します。

Herokuとは何ですか?

Herokuは、2017年にJames Lindenbaum、Adam Wiggins、Orion Henryによって最初に設立されたサービスとしてのクラウドプラットフォーム(PaaS)です。このプラットフォームは、最初はRubyプログラミング言語で作成されたプロジェクトのみをサポートするために開発されましたが、Salesforceによる買収以来2010年、プラットフォームは、Java、Node.js、Scala、Clojure、Python、PHP、Goなどの複数のプログラミング言語のサポートを追加しました。

Herokuクラウドプラットフォーム

Herokuの機能

Herokuは、アプリケーションを簡単にスケーリングおよびデプロイするためのさまざまなツールとサービスを提供します。これらのいくつかは次のとおりです。

ディノス

ほとんどすべてのクラウドサービスプロバイダーには、クラウドコンテナーの一意の名前があります。HerokuはDynoです。

Dynosは、Herokuアプリケーションの基本的なコンポーネントです。これらは分離された仮想Linuxコンテナーであり、アプリケーションの実行に必要なすべてのCPU、メモリ、およびオペレーティングシステムリソースを提供します。

Herokuは、アプリケーションのハードウェアリソースと仮想マシンを構成するストレスも解消します。ハードウェア管理について心配する代わりに、アプリをHerokuに公開するだけで、プラットフォームがすべてのアプリコードと依存関係をdynoにパッケージ化します。

アドオン

Herokuでは、さまざまなアドオンを使用してプロジェクトを拡張することもできます。これらのアドオンは、Herokuおよびサードパーティの開発者が提供する追加のクラウドサービスであり、キャッシング、データストア(Postgresのサポートを含む)などの機能をアプリケーションに追加します。 MongoDB、MySQLなど)、イベントスケジューリング、ロギング、その他多数。

運用経験

Herokuが提供するもう1つの興味深い機能は、優れたユーザーエクスペリエンスを提供しながら、アプリケーションの信頼性の維持に集中できる運用エクスペリエンスプラットフォームです。

 

このプラットフォームは、アプリケーションの状態を監視し、その応答性を検証し、ユーザーに表示される前であっても、要求の失敗に対してプロアクティブなアラートを生成するのに役立ちます。

Heroku運用エクスペリエンスプラットフォーム

価格設定

Herokuは、カスタムドメインと無料の512MB RAMプロビジョニングを含む、寛大な無料のdynoプランを提供しています。ただし、アプリケーションは30分間非アクティブになるとスリープ状態になります。つまり、リクエストがアプリケーションに送信されない場合、またはそのURLが30分ごとにアクセスされない場合、アプリケーションはスリープ状態になり、次のリクエストの読み込みには最大10秒かかります。

他のすべてのプランは、プロジェクトの要件に応じて、1ダイノあたり月額7ドルから500ドル以上までさまざまです。詳細については、価格ページをご覧ください

開発者の経験

Herokuでアプリケーションをホストするプロセスは非常に簡単です。1つのオプションは、HerokuとGitHubやGitLabなどのプロジェクト開発プラットフォームを使用してCI / CDパイプラインをセットアップすることです。もう1つのオプションは、Heroku CLIを使用することです。これは、新しいプロジェクトを作成したり、コマンドラインから直接以前のすべてのプロジェクトを管理したりするためのさらに高速な方法です。

Heroku CLIを使用すると、マーケットプレイスで入手可能なアドオンを検索してプロジェクトに追加するだけでなく、パブリックアクセス用にデプロイする前にプロジェクトをローカルでテストすることもできます。

デタとは?

Deta —ホームページに記載されている「実行者と夢想家のためのクラウド」—は、比較的新しく、完全に無料のクラウドサービスプロバイダーです。それはあなたがほんの数秒であなたのプログラムをクラウドに展開することを可能にする開発者に優しいインターフェースを提供します。プラットフォームは現在、Node.jsとPythonプロジェクトのホスティングのみをサポートしていますが、将来の追加のプログラミング言語のサポートは驚くべきことではありません。

Detaクラウドプラットフォーム

特徴

Deta Micros

HerokuのDynoのようなDetaがホストするアプリは、microsと呼ばれます。これは、プロセスの実行ごとに128MBを超えるRAMを備えたサンドボックス化されたLinux仮想マシンであり、最大512MBのストレージスペースを備えた読み取り専用ファイルシステムです。

最大2つの無料のdynoしか実行できないHerokuとは異なり、Detaでは無制限の数のマイクロを作成できます。ただし、アプリケーションのソースコードのサイズとその依存関係は250MBを超えることはできません。

Microsは現在、Node.jsとPythonのみをサポートしています。また、両方の言語の古いバージョンはサポートされていないことにも注意してください。これは将来変更される可能性がありますが、現在次のバージョンがサポートされています。

  • Nodejs:12.x、14.x
  • Python:3.7、3.8、3.9

Deta Base

Detaは、PostgresやMySQLなどのリレーショナルデータベースで動作するように設定されていないため、チームは、プラットフォームでホストされるアプリケーション用に特別に設計された独自の安全なNoSQLデータベースを開発しました。

Deta Baseは、エンドユーザーの利便性を優先する高速でスケーラブルなNoSQLデータベースです。ユーザーインターフェイスと、データベース内のレコードを管理およびクエリできるSDKがあります。データベースはJavascript、Python、Go SDKとして利用でき、構文はかなり単純です。データベースにレコードを挿入および削除する方法の例を次に示します。

const { Deta } = require('deta');

// Project key retrieved from deta dashboard
const deta = Deta('your-project-key'); 

// Connect to or create a new 'users' database.
const users = deta.Base('users'); 

// Add new user to the database.
users.put({name: "Elijah", state: 'Lagos'})

// delete user with key 'one'
const res = await db.delete("one")

デタドライブ

安全でスケーラブルなファイルストレージソリューションであるDetaDriveは、プラットフォームが提供するもう1つのサービスです。Deta Driveが画像、ビデオ、その他の種類のメディアなどのファイル/アセット管理に重点を置いているのに対し、Deta Baseはデータ管理に重点を置いていることを除けば、DetaBaseと非常によく似ています。すべてのアカウントは10GBのストレージに制限されています。これは無料であることを考えるとかなり寛大なオファーであり、ドライブに保存されているすべてのファイルはダッシュボードから直接管理することも、SDKを介してプログラムで管理することもできます。

価格設定

Herokuとは異なり、Detaはすべてのサービスを無料で提供しており、開始するためにクレジットカードの詳細やその他の機密性の高い支払い情報を提供する必要はありません。

開発者の経験

Detaには、Herokuと同様に、既存のすべてのプロジェクトを管理したり、新しいプロジェクトを作成したりするための統合CLIがあります。Herokuとは異なり、Detaは現在CI / CDをサポートしていません。つまり、GitHubまたはGitLabプロジェクトをDetaに同期して、プッシュされた新しい変更を反映することはできません。

最終的な考え

この記事全体を通して、最も人気のあるクラウドサービスプロバイダーの1つであるHerokuを、新しい完全に無料のオプションであるDetaと比較しました。どちらのプラットフォームも優れたサービスを提供します。

ただし、当面は、Detaの方が高速で稼働しますが、エンタープライズアプリではHerokuを検討する必要があります。また、Detaはまだ比較的若いので、将来的には多くの興味深い更新を期待する必要があります。

リンク:https//blog.logrocket.com/deta-vs-heroku-finding-better-cloud-provider/

#heroku #deta 

DetaとHerokuを比較して、より優れたクラウドプロバイダーを見つける

Url Shortener Elitmus Written in Flask

url-shortener-elitmus

This is a simple flask app which takes an URL and shortens it. This shortened verion of the URL redirects to the user to the long URL.

For each long URL given by the user the application randomly generates an alphabetical combination which redirects to the long URL which is 20 characters long entirely.

Webiste hosted on heroku

hosted site link : https://uzx.herokuapp.com/

example image

Salient Features

  • All the shortened links and the original link are available in a table along with the number of times a shortened link has been visited.
  • The total length of the shortened url is 20 characters long (excluding https://)

Setting Up in local

Clone the repository

git clone https://github.com/shriramrahul7/url-shortner-elitmus.git

Change directory

cd url-shortner-elitmus

Setup the local environment using the requirements.txt file

pip install -r requirements.txt

then, just ensure that you have your sqlite running

and now to execute the app

python3 app.py

Download Details:
Author: shriramrahul7
Source Code: https://github.com/shriramrahul7/url-shortner-elitmus
License: 

#flask #python #heroku 

Url Shortener Elitmus Written in Flask

Covid 19 Status Flask Application with CovidAPI, Heroku and Python

Covid 19

In this project we see total count of people who got this virus and total death.

How does it works

  • Written in Python.
  • Web app, Flask.
  • package managing with PipEnv.
  • Using CovidAPI.
  • Domain with CloudFlare.
  • Developed by Amirhossein.
  • Hosted by Heroku.

Where to see

Open covid-blackiq.herokuapp.com/.

Contribute

For small changes, open an issue or do it by yourself.

How to run

  • First clone it and go to the directory. Run pipenv shell.

This project is using PipEnv. Don't run pip3 install.

$ git clone https://github.com/BlackIQ/covid
$ cd covid
$ pipenv shell
  • Export variables and run Flask app.
$ export FLASK_APP=wsgi.py
$ export FLASK_ENV=development
$ flask run
  • After go to 127.0.0.1:5000 in your broswer.

ScreenShot

Hacktoberfest

Now is October 9 and here is Hacktoberfest. Contribute on this project to get label.

The last word

Protect your self, Wear a mask. Get vaccinated if you have not already.

License

This project is licensed under GPL-3 license

TODO

  •  Front-End design
  •  Deploy

Download Details:
Author: BlackIQ
Source Code: https://github.com/BlackIQ/covid
License: 

#flask #python #heroku 

Covid 19 Status Flask Application with CovidAPI, Heroku and Python

Presentamos el Modelo PyTorch usando Flask y Heroku

Cree e implemente su primera aplicación de aprendizaje profundo. En este tutorial de PyTorch, aprenderá a implementar un modelo de PyTorch usando Flask y Heroku. Cree una aplicación Flask simple utilizando la API REST que devuelve el resultado como datos json e impleméntelo en Heroku. Como ejemplo de la aplicación PytTorch, puede clasificar números, dibujar sus propios números al final y hacer predicciones en la aplicación de ejecución en vivo.

Configuración

Cree un proyecto en un entorno virtual (los comandos pueden variar ligeramente en Windows).

$ mkdir pytorch-deploy
$ cd pytorch-deploy
$ python3 -m venv venv

Activarlo

$ . venv/bin/activate

O para Windows

venv\Scripts\activate

Instalar Flask y PyTorch

$ pip install Flask
$ pip install torch torchvision

Crea una aplicación

Cree una nueva aplicación de directorio e inserte lo siguiente dentro de este archivo main.py :

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    if request.method == 'POST':
        return jsonify({'test': 'test_result'})

Solo se requiere un punto final @app.route('/predict'). Aquí tomamos una imagen, la predecimos con un modelo de PyTorch y devolvemos el resultado como datos json. Por ahora, los jsonifymétodos de Flask solo devuelven datos json ficticios.

Ejecuta y prueba la aplicación

Correr

$ export FLASK_APP=app/main.py
$ export FLASK_ENV=development
$ flask run

Cree una carpeta de prueba test e insértela dentro del archivo test.py.

import requests 

resp = requests.post("http://localhost:5000/predict")

print(resp.text)

Ejecute el archivo test.py en la segunda terminal (es posible que deba instalar la solicitud :)pip install requests . Si todo funciona correctamente, esto generará datos json ficticios {'test': 'test_result'}.

Entrena y guarda tu modelo.

Aquí se obtiene el código de mi PyTorch supuesto que . Esta es una red neuronal de retroalimentación simple entrenada en el conjunto de datos MNIST y utilizada para clasificar números. El único cambio que hacemos es agregar otra transformación de conjunto de datos. Esto se debe a que queremos mostrar que la aplicación necesita la misma conversión. Por lo tanto, primero use esta transformación para aplicarla a su conjunto de datos.

transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])

# MNIST dataset 
train_dataset = torchvision.datasets.MNIST(root='./data', 
                                           train=True, 
                                           transform=transform,  
                                           download=True)

test_dataset = torchvision.datasets.MNIST(root='./data', 
                                          train=False, 
                                          transform=transform)

Esto es solo una normalización con la media global y la desviación estándar del conjunto de datos MNIST.

Inserte esta línea al final del archivo para guardar el modelo después del entrenamiento.

torch.save(model.state_dict(), "mnist_ffn.pth")

Luego ejecute este archivo. Esto entrena el modelo, lo imprime con alta precisión y guarda el modelo en el archivo especificado. Obtén este archivo y cópialo en tu carpeta de aplicaciones .

Crear una función de utilidad PyTorch

Cree un nuevo archivo torch_utils.py en la carpeta de la aplicación . Aquí hacemos tres cosas:

  • Cargar el modelo
  • Preprocese la imagen y conviértala en un tensor de antorcha
  • Haz una predicción

Cargar el modelo

Consulte también este curso de PyTorch para guardar y cargar . Cree el mismo modelo que el archivo original, cargue el diccionario de estado y configúrelo en modo. Aquí solo se utiliza la versión de la CPU. De lo contrario, el paquete es demasiado grande para Heroku. Por lo tanto, si se entrenó en la GPU, asegúrese de que se cargue correctamente. También puede encontrar este código en el tutorial de guardar / cargar. Puede eliminar todas las llamadas de su código. No te preocupes. La CPU funciona lo suficientemente rápido como para inferir el modelo en esta aplicación.eval.to(device)

import io
import torch 
import torch.nn as nn 
import torchvision.transforms as transforms 
from PIL import Image


class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet, self).__init__()
        self.input_size = input_size
        self.l1 = nn.Linear(input_size, hidden_size) 
        self.relu = nn.ReLU()
        self.l2 = nn.Linear(hidden_size, num_classes)  
    
    def forward(self, x):
        out = self.l1(x)
        out = self.relu(out)
        out = self.l2(out)
        # no activation and no softmax at the end
        return out

input_size = 784 # 28x28
hidden_size = 500 
num_classes = 10
model = NeuralNet(input_size, hidden_size, num_classes)

PATH = "mnist_ffn.pth"
model.load_state_dict(torch.load(PATH))
model.eval()

Cargar y convertir imágenes

Aquí nos aseguramos de que el tensor tenga las mismas propiedades que el conjunto de datos MNIST. Por lo tanto, aplique las mismas conversiones que el archivo original. Además, cambie el tamaño de la imagen a (28,28) y conviértala en una imagen en escala de grises. Agregue esta función al archivo torch_utils.py .

def transform_image(image_bytes):
    transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),
                                    transforms.Resize((28,28)),
                                    transforms.ToTensor(),
                                    transforms.Normalize((0.1307,),(0.3081,))])

    image = Image.open(io.BytesIO(image_bytes))
    return transform(image).unsqueeze(0)

predecir

Ahora use el mismo código que el archivo original para predecir la imagen y devolver la predicción con la nueva función auxiliar.

def get_prediction(image_tensor):
    images = image_tensor.reshape(-1, 28*28)
    outputs = model(images)
        # max returns (value ,index)
    _, predicted = torch.max(outputs.data, 1)
    return predicted

Poner todo junto

En el archivo main.py , predictcómo importar estas funciones auxiliares y ejecutarlas todas juntas . Además, también incluye algunas comprobaciones de errores, permitiendo solo ciertos archivos.

from flask import Flask, request, jsonify

from torch_utils import transform_image, get_prediction

app = Flask(__name__)

ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}
def allowed_file(filename):
    # xxx.png
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS


@app.route('/predict', methods=['POST'])
def predict():
    if request.method == 'POST':
        file = request.files.get('file')
        if file is None or file.filename == "":
            return jsonify({'error': 'no file'})
        if not allowed_file(file.filename):
            return jsonify({'error': 'format not supported'})

        try:
            img_bytes = file.read()
            tensor = transform_image(img_bytes)
            prediction = get_prediction(tensor)
            data = {'prediction': prediction.item(), 'class_name': str(prediction.item())}
            return jsonify(data)
        except:
            return jsonify({'error': 'error during prediction'})

Tenga en cuenta que en este conjunto de datos prediction, class_namees el mismo que. Normalmente, debe hacer el mapeo del índice al nombre real de la clase aquí.

Prueba el modelo

Luego, tome algunas imágenes de muestra o use un programa de pintura simple para dibujar su propia imagen. En mi caso, en el Mac se usó pincel para crear una nueva imagen de tamaño 100x100, rellenar el fondo con negro, se dibujó números en blanco. Guarde como png o jpg y copie el archivo a la carpeta de prueba . Luego, incluye esta imagen en tu solicitud de publicación. Por ejemplo, Eight.Png la imagen que utilice usted.

import requests 

resp = requests.post("http://localhost:5000/predict", files={'file': open('eight.png', 'rb')})

print(resp.text)

Esto debe imprimirse {'prediction': 8, 'class_name': 8}. enhorabuena! Ahora tiene una aplicación web PyTorch en ejecución. Como paso final, implemente en Heroku

Implementar en Heroku

La producción en el medio ambiente , el servidor Web apropiado es tan necesario, Gunicorn instalar que .

$ pip install gunicorn

Todos los siguientes archivos deben agregarse al directorio base. Primero, cree un archivo wsgi.py e inserte esta línea

from app.main import app

Procfile cree un, esto e inserte el.

web: gunicorn wsgi:app

Cambie el nombre de la ruta para basarla en el paquete de su aplicación .

# in the main.py file:
from app.torch_utils import get_prediction, transform_image

# in the torch_utils.py file
PATH = "app/mnist_ffn.pth"

Cree runtime.txt e inserte la versión de Python que está utilizando .

python-3.8.3

Asegúrese de estar nuevamente en la carpeta raíz del paquete. Luego, todos los paquetes con los siguientes requisitos.txt y agregarlo al archivo pip freeze.

$ pip freeze > requirements.txt

Solo está disponible la versión de CPU, así que modifique el archivo de esta manera para usar la versión de PyTorch solo para CPU. Puede obtener la versión del comando solo para CPU en esta guía de instalación de PyTorch . Seleccione Linux, pip y no CUDA. Puede agregar el comando de descarga como la primera línea en el archivo requirements.txt .

-f https://download.pytorch.org/whl/torch_stable.html
torch==1.6.0+cpu
torchvision==0.7.0+cpu

El .gitignore te agrega . Esta versión de Python es, GitHub se puede obtener de usted . Además, agregue una carpeta de prueba para que la primera línea del archivo contenga la siguiente línea:

test/

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
...

Crea una aplicación Heroku. Para hacer esto, necesita instalar Heroku CLI. Aquí usted puede conseguir que . Inicie sesión y cree una nueva aplicación con el nombre que desee.

$ heroku login -i
$ heroku create your-app-name

Pruebe su aplicación localmente.

$ heroku local

Luego agregue un repositorio de git, confirme todos los archivos y envíelos a Heroku.

git init
heroku git:remote -a your-app-name
git add .
git commit -m "initial commit"
git push heroku master

Esto implementará su aplicación en Heroku y le mostrará un enlace a la aplicación que se ejecuta en vivo. Luego use esta URL en su archivo test.py de la siguiente manera:

import requests

resp = requests.post("https://your-app-name.herokuapp.com/predict",
                     files={"file": open('eight.png','rb')})

print(resp.text)

enhorabuena! Ahora tiene una aplicación de ejecución en vivo con un modelo de PyTorch que puede realizar la clasificación de números. Tenga en cuenta que si solo usa el nivel gratuito, Heroku deberá activar su aplicación primero, por lo que puede tomar unos segundos enviar su primera solicitud.

¿Has disfrutado de este tutorial?

Enlace: https://www.python-engineer.com/posts/pytorch-model-deployment-with-flask/

#pytorch  #flask #heroku 

Presentamos el Modelo PyTorch usando Flask y Heroku

FlaskとHerokuを使用したPyTorchモデルの導入

最初のディープラーニングアプリを作成してデプロイします。このPyTorchチュートリアルでは、FlaskとHerokuを使用してPyTorchモデルをデプロイする方法を学習します。結果をjsonデータとして返すRESTAPIを使用して単純なFlaskアプリを作成し、それをHerokuにデプロイします。PytTorchアプリの例として、数字の分類を行い、最後に独自の数字を描画して、ライブ実行アプリで予測することができます。

設定

仮想環境でプロジェクトを作成します(Windowsではコマンドが若干異なる場合があります)。

$ mkdir pytorch-deploy
$ cd pytorch-deploy
$ python3 -m venv venv

それをアクティブにします

$ . venv/bin/activate

またはWindowsの場合

venv\Scripts\activate

FlaskとPyTorchをインストールします

$ pip install Flask
$ pip install torch torchvision

アプリを作成する

新しいディレクトリアプリを作成し、このmain.pyファイル内に以下を挿入します。

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    if request.method == 'POST':
        return jsonify({'test': 'test_result'})

必要なエンドポイントは1つだけです@app.route('/predict')。ここでは、画像を受け取り、PyTorchモデルで予測して、結果をjsonデータとして返します。今のところ、Flaskのjsonifyメソッドでダミーのjsonデータのみを返します。

アプリを実行してテストします

走る

$ export FLASK_APP=app/main.py
$ export FLASK_ENV=development
$ flask run

テストフォルダーtestを作成し、test.pyファイル内に挿入します。

import requests 

resp = requests.post("http://localhost:5000/predict")

print(resp.text)

2番目のターミナルでtest.pyファイルを実行します(リクエストをインストールする必要がある場合があります:)pip install requests。すべてが正しく機能している場合、これによりダミーのjsonデータが出力されます{'test': 'test_result'}

モデルをトレーニングして保存します。

ここで私のPyTorchコースからコードを取得します。これは、MNISTデータセットでトレーニングされ、数字の分類に使用される単純なフィードフォワードニューラルネットです。私たちが行う唯一の変更は、別のデータセット変換を追加することです。これは、アプリでも同じ変換が必要であることを示したいためです。したがって、最初にこの変換を使用して、データセットに適用します。

transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])

# MNIST dataset 
train_dataset = torchvision.datasets.MNIST(root='./data', 
                                           train=True, 
                                           transform=transform,  
                                           download=True)

test_dataset = torchvision.datasets.MNIST(root='./data', 
                                          train=False, 
                                          transform=transform)

これは、MNISTデータセットのグローバル平均と標準偏差による正規化にすぎません。

ファイルの最後に、この行を挿入して、トレーニング後にモデルを保存します。

torch.save(model.state_dict(), "mnist_ffn.pth")

次に、このファイルを実行します。これにより、モデルがトレーニングされ、高精度で印刷され、指定されたファイルにモデルが保存されます。このファイルを取得して、アプリフォルダーにコピーします。

PyTorchユーティリティ関数を作成する

appフォルダー内に新しいファイルtorch_utils.pyを作成します。ここでは、次の3つのことを行います。

  • モデルをロードします
  • 画像を前処理し、トーチテンソルに変換します
  • 予測を行う

モデルをロードします

保存と読み込みについては、こちらのPyTorchコースもご覧ください。元のファイルと同じモデルを作成し、状態ディクショナリをロードして、evalモードに設定します。ここではCPUバージョンのみを使用します。それ以外の場合、パッケージはHerokuには大きすぎます。したがって、GPUでトレーニングした場合は、正しくロードするようにしてください。このコードは、保存/読み込みのチュートリアルにもあります。.to(device)コードからすべての呼び出しを削除できます。心配はいりません。CPUは、このアプリケーションでモデルを推論するのに十分な速度で動作します。

import io
import torch 
import torch.nn as nn 
import torchvision.transforms as transforms 
from PIL import Image


class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet, self).__init__()
        self.input_size = input_size
        self.l1 = nn.Linear(input_size, hidden_size) 
        self.relu = nn.ReLU()
        self.l2 = nn.Linear(hidden_size, num_classes)  
    
    def forward(self, x):
        out = self.l1(x)
        out = self.relu(out)
        out = self.l2(out)
        # no activation and no softmax at the end
        return out

input_size = 784 # 28x28
hidden_size = 500 
num_classes = 10
model = NeuralNet(input_size, hidden_size, num_classes)

PATH = "mnist_ffn.pth"
model.load_state_dict(torch.load(PATH))
model.eval()

画像を読み込んで変換する

ここでは、テンソルがMNISTデータセットと同じプロパティを持っていることを確認します。したがって、元のファイルと同じ変換を適用します。さらに、画像のサイズを(28,28)に変更し、グレースケール画像に変換します。この関数をtorch_utils.pyファイルに追加します。

def transform_image(image_bytes):
    transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),
                                    transforms.Resize((28,28)),
                                    transforms.ToTensor(),
                                    transforms.Normalize((0.1307,),(0.3081,))])

    image = Image.open(io.BytesIO(image_bytes))
    return transform(image).unsqueeze(0)

予測

ここで、元のファイルと同じコードを使用して画像を予測し、新しいヘルパー関数で予測を返します。

def get_prediction(image_tensor):
    images = image_tensor.reshape(-1, 28*28)
    outputs = model(images)
        # max returns (value ,index)
    _, predicted = torch.max(outputs.data, 1)
    return predicted

すべてをまとめる

main.pyファイル、これらのヘルパー関数をインポートして、一緒にすべてをかけるpredict方法。さらに、いくつかのエラーチェックも含まれており、特定のファイルのみを許可します。

from flask import Flask, request, jsonify

from torch_utils import transform_image, get_prediction

app = Flask(__name__)

ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}
def allowed_file(filename):
    # xxx.png
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS


@app.route('/predict', methods=['POST'])
def predict():
    if request.method == 'POST':
        file = request.files.get('file')
        if file is None or file.filename == "":
            return jsonify({'error': 'no file'})
        if not allowed_file(file.filename):
            return jsonify({'error': 'format not supported'})

        try:
            img_bytes = file.read()
            tensor = transform_image(img_bytes)
            prediction = get_prediction(tensor)
            data = {'prediction': prediction.item(), 'class_name': str(prediction.item())}
            return jsonify(data)
        except:
            return jsonify({'error': 'error during prediction'})

このデータセットpredictionclass_nameは、とは同じであることに注意してください。通常、ここでインデックスから実際のクラス名へのマッピングを行う必要があります。

モデルをテストする

次に、いくつかのサンプル画像を取得するか、簡単なペイントプログラムを使用して独自の画像を描画します。私の場合、Macでペイントブラシを使用し、サイズ100x100の新しい画像を作成し、背景を黒で塗りつぶし、数字を白で描画しました。pngまたはjpgで保存し、ファイルをテストフォルダーにコピーします。次に、この画像を投稿リクエストに含めます。たとえば、eight.pngという画像を使用します。

import requests 

resp = requests.post("http://localhost:5000/predict", files={'file': open('eight.png', 'rb')})

print(resp.text)

これは印刷する必要があります{'prediction': 8, 'class_name': 8}。おめでとう!これで、実行中のPyTorchWebアプリができました。最後のステップとして、Herokuにデプロイします

Herokuにデプロイする

本番環境では、適切なWebサーバーが必要なので、gunicornをインストールします

$ pip install gunicorn

以下のすべてのファイルをベースディレクトリに追加する必要があります。まず、wsgi.pyファイルを作成し、この行を挿入します

from app.main import app

Procfileを作成し、これを挿入します。

web: gunicorn wsgi:app

パス名を変更して、アプリパッケージをベースにします。

# in the main.py file:
from app.torch_utils import get_prediction, transform_image

# in the torch_utils.py file
PATH = "app/mnist_ffn.pth"

runtime.txtを作成し、使用しているPythonバージョンを挿入します。

python-3.8.3

パッケージのルートフォルダに再度いることを確認してください。次に、以下を使用してすべてのパッケージをrequirements.txtファイルに追加しますpip freeze

$ pip freeze > requirements.txt

CPUバージョンしか使用できないため、このようにファイルを変更して、PyTorchのCPUのみのバージョンを使用します。CPUのみのバージョンのコマンドは、こちらのPyTorchインストールガイドから取得できます。Linux、pip、およびCUDAなしを選択します。ダウンロードコマンドは、requirements.txtファイルの最初の行として追加できます。

-f https://download.pytorch.org/whl/torch_stable.html
torch==1.6.0+cpu
torchvision==0.7.0+cpu

.gitignoreを追加します。このバージョンのPythonは、GitHubから入手できます。また、テストフォルダーを追加して、ファイルの最初の行に次の行が含まれるようにします。

test/

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
...

Herokuアプリを作成します。このためには、HerokuCLIをインストールする必要があります。ここで入手できます。ログインして、目的の名前で新しいアプリを作成します。

$ heroku login -i
$ heroku create your-app-name

アプリをローカルでテストします。

$ heroku local

次に、gitリポジトリを追加し、すべてのファイルをコミットして、Herokuにプッシュします。

git init
heroku git:remote -a your-app-name
git add .
git commit -m "initial commit"
git push heroku master

これにより、アプリがHerokuにデプロイされ、ライブで実行されているアプリへのリンクが表示されます。次に、このURLをtest.pyファイルで次のように使用しましょう。

import requests

resp = requests.post("https://your-app-name.herokuapp.com/predict",
                     files={"file": open('eight.png','rb')})

print(resp.text)

おめでとう!これで、数字の分類を実行できるPyTorchモデルを備えたライブ実行アプリができました。無料利用枠のみを使用する場合、Herokuは最初にアプリをウェイクアップする必要があるため、最初にリクエストを送信するときは数秒かかる場合があることに注意してください。

このチュートリアルを楽しんでいただけたでしょうか。

リンク: https://www.python-engineer.com/posts/pytorch-model-deployment-with-flask/

#pytorch #flask #heroku 

FlaskとHerokuを使用したPyTorchモデルの導入

Heroku View Logs in CLI (Command Line)

In this video, I'd like to share with you how to view logs of deployed apps on Heroku cloud platform, in Heroku CLI (command line interface).
In details, you will learn about the basics of logging in Heroku. And then I will show you:
- how to view most recent logs
- how to filter logs by some certain sources (app logs, system logs, API logs...)
- how to view logs in real time

#heroku 

Heroku View Logs in CLI (Command Line)
Effie  Predovic

Effie Predovic

1641003360

Fixed Heroku Deployment Issue for React App with JSON Server

In this video, I will show how you can fix the issue related to heroku deployment of React App with JSON Server. The main motive of creating this video to address issue for those people who have face issue with post Heroku Deployment of React App.

#heroku #react 

Fixed Heroku Deployment Issue for React App with JSON Server

Heroku View Build Logs of Apps

In this video, you will learn how to view build logs of an application deployed on Heroku, for the purpose of troubleshooting deployment problems.
You need to login to Heroku in order to view build logs of your apps.

#heroku 

Heroku View Build Logs of Apps
Effie  Predovic

Effie Predovic

1640657520

Build and Deploy React App using JSON Server on Heroku

Hello, everyone in this video we are going build react crud application using JSON Server then we will deploy our react application on Heroku plateform.

#reactjs #heroku 

Build and Deploy React App using JSON Server on Heroku

Heroku Login in Command Line / Terminal

How to log in to Heroku Command Line Interface (Heroku CLI) in command line (Windows) or terminal (Mac, Linux). And how to logout from Heroku CLI to clear login session.

#heroku 

Heroku Login in Command Line / Terminal

Building Search users in Github Created with Flask, PipEnv, Heroku

Search in Github

Here search for users in Github and other stuff!

This app is working with,

  • Data Github API
  • BackEnd Flask
  • Language Python
  • Package manager PipEnv
  • Hosted Heroku
  • Source on Github

Where to see

Open us-search.herokuapp.com.

Contribute

For small changes, open an issue or do it by yourself.

How to run

  • First clone it and go to the directory. Run pipenv shell.

This project is using PipEnv. Don't run pip3 install.

$ git clone https://github.com/BlackIQ/UG-Search
$ cd covid
$ pipenv shell
  • Export variables and run Flask app.
$ export FLASK_APP=wsgi.py
$ export FLASK_ENV=development
$ flask run
  • After go to 127.0.0.1:5000 in your broswer.

ScreenShot

Some screenshots

ScreenShot

ScreenShot

ScreenShot

Hacktoberfest

Now is October 12 and here is Hacktoberfest. Contribute on this project to get label.

License

This project is licensed under GPL-3 license

TODO

  •  Front-End design
  •  Deploy
  •  Search organization
  •  Search repository

Download Details:
Author: BlackIQ
Source Code: https://github.com/BlackIQ/UG-Search
License: GPL-3.0 License

#python #flask #github #heroku #PipEnv

Building Search users in Github Created with Flask, PipEnv, Heroku
HI Python

HI Python

1640092029

Wafer Fault Detection with Python

Wafer Fault Detection

Problem Statement:

Wafer (In electronics), also called a slice or substrate, is a thin slice of semiconductor,
such as a crystalline silicon (c-Si), used for fabricationof integrated circuits and in photovoltaics,
to manufacture solar cells.

The inputs of various sensors for different wafers have been provided.
The goal is to build a machine learning model which predicts whether a wafer needs to be replaced or not
(i.e whether it is working or not) nased on the inputs from various sensors.
There are two classes: +1 and -1.
+1: Means that the wafer is in a working condition and it doesn't need to be replaced.
-1: Means that the wafer is faulty and it needa to be replaced.

Data Description

The client will send data in multiple sets of files in batches at a given location.
Data will contain Wafer names and 590 columns of different sensor values for each wafer.
The last column will have the "Good/Bad" value for each wafer.

Apart from training files, we laso require a "schema" file from the client, which contain all the
relevant information about the training files such as:

Name of the files, Length of Date value in FileName, Length of Time value in FileName, NUmber of Columnns, 
Name of Columns, and their dataype.

Data Validation

In This step, we perform different sets of validation on the given set of training files.

Name Validation: We validate the name of the files based on the given name in the schema file. We have 
created a regex patterg as per the name given in the schema fileto use for validation. After validating 
the pattern in the name, we check for the length of the date in the file name as well as the length of time 
in the file name. If all the values are as per requirements, we move such files to "Good_Data_Folder" else
we move such files to "Bad_Data_Folder."

Number of Columns: We validate the number of columns present in the files, and if it doesn't match with the
value given in the schema file, then the file id moves to "Bad_Data_Folder."

Name of Columns: The name of the columns is validated and should be the same as given in the schema file. 
If not, then the file is moved to "Bad_Data_Folder".

The datatype of columns: The datatype of columns is given in the schema file. This is validated when we insert
the files into Database. If the datatype is wrong, then the file is moved to "Bad_Data_Folder."

Null values in columns: If any of the columns in a file have all the values as NULL or missing, we discard such
a file and move it to "Bad_Data_Folder".

Data Insertion in Database

 Database Creation and Connection: Create a database with the given name passed. If the database is already created,
 open the connection to the database.
 
 Table creation in the database: Table with name - "Good_Data", is created in the database for inserting the files 
 in the "Good_Data_Folder" based on given column names and datatype in the schema file. If the table is already
 present, then the new table is not created and new files are inserted in the already present table as we want 
 training to be done on new as well as old training files.
 
 Insertion of file in the table: All the files in the "Good_Data_Folder" are inserted in the above-created table. If
 any file has invalid data type in any of the columns, the file is not loaded in the table and is moved to 
 "Bad_Data_Folder".
 

Model Training

 Data Export from Db: The data in a stored database is exported as a CSV file to be used for model training.
 
 Data Preprocessing: 
    Check for null values in the columns. If present, impute the null values using the KNN imputer.
    
    Check if any column has zero standard deviation, remove such columns as they don't give any information during 
    model training.
    
 Clustering: KMeans algorithm is used to create clusters in the preprocessed data. The optimum number of clusters 
 is selected

Create a file "Dockerfile" with below content

FROM python:3.7
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
ENTRYPOINT [ "python" ]
CMD [ "main.py" ]

Create a "Procfile" with following content

web: gunicorn main:app

create a file ".circleci\config.yml" with following content

version: 2.1
orbs:
  heroku: circleci/heroku@1.0.1
jobs:
  build-and-test:
    executor: heroku/default
    docker:
      - image: circleci/python:3.6.2-stretch-browsers
        auth:
          username: mydockerhub-user
          password: $DOCKERHUB_PASSWORD  # context / project UI env-var reference
    steps:
      - checkout
      - restore_cache:
          key: deps1-{{ .Branch }}-{{ checksum "requirements.txt" }}
      - run:
          name: Install Python deps in a venv
          command: |
            echo 'export TAG=0.1.${CIRCLE_BUILD_NUM}' >> $BASH_ENV
            echo 'export IMAGE_NAME=python-circleci-docker' >> $BASH_ENV
            python3 -m venv venv
            . venv/bin/activate
            pip install --upgrade pip
            pip install -r requirements.txt
      - save_cache:
          key: deps1-{{ .Branch }}-{{ checksum "requirements.txt" }}
          paths:
            - "venv"
      - run:
          command: |
            . venv/bin/activate
            python -m pytest -v tests/test_script.py
      - store_artifacts:
          path: test-reports/
          destination: tr1
      - store_test_results:
          path: test-reports/
      - setup_remote_docker:
          version: 19.03.13
      - run:
          name: Build and push Docker image
          command: |
            docker build -t $DOCKERHUB_USER/$IMAGE_NAME:$TAG .
            docker login -u $DOCKERHUB_USER -p $DOCKER_HUB_PASSWORD_USER docker.io
            docker push $DOCKERHUB_USER/$IMAGE_NAME:$TAG
  deploy:
    executor: heroku/default
    steps:
      - checkout
      - run:
          name: Storing previous commit
          command: |
            git rev-parse HEAD > ./commit.txt
      - heroku/install
      - setup_remote_docker:
          version: 18.06.0-ce
      - run:
          name: Pushing to heroku registry
          command: |
            heroku container:login
            #heroku ps:scale web=1 -a $HEROKU_APP_NAME
            heroku container:push web -a $HEROKU_APP_NAME
            heroku container:release web -a $HEROKU_APP_NAME

workflows:
  build-test-deploy:
    jobs:
      - build-and-test
      - deploy:
          requires:
            - build-and-test
          filters:
            branches:
              only:
                - main

to create requirements.txt

pip freeze>requirements.txt

initialize git repo

git init
git add .
git commit -m "first commit"
git branch -M main
git remote add origin <github_url>
git push -u origin main

create a account at circle ci

Circle CI

setup your project

Setup project

Select project setting in CircleCI and below environment variable

DOCKERHUB_USER
DOCKER_HUB_PASSWORD_USER
HEROKU_API_KEY
HEROKU_APP_NAME
HEROKU_EMAIL_ADDRESS
DOCKER_IMAGE_NAME=wafercircle3270303

to update the modification

git add .
git commit -m "proper message"
git push 

#docker login -u $DOCKERHUB_USER -p $DOCKER_HUB_PASSWORD_USER docker.io

Download Details:
Author: Avnish327030
Source Code: https://github.com/Avnish327030/wafer_circleci
License: 

#python #docker 

Wafer Fault Detection with Python

Flask Heroku Cacheify - Automatic Flask Cache Configuration on Heroku

flask-heroku-cacheify

Automatic Flask cache configuration on Heroku.

Thinking Man Sketch

Purpose

Configuring your cache on Heroku can be a time sink. There are lots of different caching addons available on Heroku (Redis, Memcached, etc.), and among those -- lots of competitors.

flask-heroku-cacheify makes your life easy by automatically configuring your Flask application to work with whatever caching addons you've got provisioned on Heroku, allowing you to easily swap out addon providers at will, without any trouble. And, just in case you don't have any suitable Heroku addons available, flask-heroku-cacheify will default back to using local memory for your cache!

Instead of looking through documentation, testing stuff out, etc., flask-heroku-cacheify will just do everything for you :)

Install

To install flask-heroku-cacheify, use pip.

$ pip install flask-heroku-cacheify

NOTE: If you're install flask-heroku-cacheify locally, you'll need to have libmemcached-dev installed on your OS (with SASL support).

Next, modify your requirements.txt file in your home directory, and add the following to the bottom of your file:

Flask-Heroku-Cacheify>=1.3
pylibmc>=1.2.3

The above will ensure that Heroku pulls in the required C header files (in case you decide to use memcached). This step is required.

Pick an Addon

Heroku has lots of available addons you can use for caching. flask-heroku-cacheify currently works with them all! That means no matter which option you choose, your cache will work out of the box, guaranteed!

Below is a list of the addons you can install to get started, you should have at least one of these activated on your Heroku app -- otherwise, your cache will be in 'local memory' only, and won't be very useful.

NOTE My favorite providers are MemCachier (for memcache), and openredis for redis. Both are equally awesome as cache providers. If you're in need of a stable cache provider for large applications, I'd recommend RedisGreen -- they use dedicated EC2 instances (which greatly improves your server power) and have an excellent interface.

Usage

Using flask-heroku-cacheify is super easy! In your app.py (or wherever you define your Flask application), add the following:

from flask_cacheify import init_cacheify

app = Flask(__name__)
cache = init_cacheify(app)

Once you've got your cache global defined, you can use it anywhere in your Flask app:

>>> from app import cache
>>> cache.set('hi', 'there', 30)
>>> cache.get('hi')
'there'

How does this work? In the background, flask-heroku-cacheify is really just automatically configuring the popular Flask-Cache extension! This means, you can basically skip down to this part of their documentation, and begin using all the methods listed there, without worrying about setting up your caches! Neat, right?

For more information and examples of how to use your cache, don't forget to read the Flask-Cache documentation.

Changelog

1.6.1: 12-20-2017

- Update docs
- Updating code to support latest Flask release

1.6.0: 04-22-2017

- Upgrading to work with latest FLask release (thanks @mattstibbs).

v1.5: 06-20-2015

- Removing MyRedis addon support -- the addon has been shut down.

v1.4: 04-04-2015

- Fixing typos in README.
- Adding Python 3 compatibility.

v1.3: 05-31-2012

- Fixing bug with memcachier support (thanks @eriktaubeneck)!

v1.2: 04-18-2013

- Adding proper documentation.

v1.1: 04-18-2013

- Adding support for MyRedis.
- Adding support for Redis Cloud.
- Adding support for Redis To Go.
- Adding support for openredis.

v1.0: 04-18-2013

- Fixing bug with RedisGreen support.

v0.9: 04-18-2013

- First *real* release! Supports MemCachier and RedisGreen!

v0.8: 04-18-2013

- Pushing eigth release to PyPI (don't use this still!).

v0.7: 04-18-2013

- Pushing seventh release to PyPI (don't use this still!).

v0.6: 04-18-2013

- Pushing sixth release to PyPI (don't use this still!).

v0.5: 04-18-2013

- Pushing fifth release to PyPI (don't use this still!).

v0.4: 04-18-2013

- Pushing fourth release to PyPI (don't use this still!).

v0.3: 04-18-2013

- Pushing third release to PyPI (don't use this still!).

v0.2: 04-18-2013

- Pushing second release to PyPI (don't use this still!).

v0.1: 04-18-2013

- Pushing first release to PyPI (don't use this yet!).

v0.0: 04-14-2013

- Started work >:)

Download Details:
Author: rdegges
Source Code: https://github.com/rdegges/flask-heroku-cacheify
License:  Unlicense License

#flask #heroku #python 

Flask Heroku Cacheify - Automatic Flask Cache Configuration on Heroku

Host Your Django Project on Heroku for Free

How to Deploy Django Project on Heroku for Free | Step by Step Tutorial

In this video, I'm gonna be showing you the step by step tutorial on how to deploy django app on heroku for free. Heroku is a free PaaS provider on which you can deploy django project on server.

Guide Link : https://github.com/akjasim/codeband-django-heroku 

#django #heroku #python 

Host Your Django Project on Heroku for Free