One place for hosting & domains

      Consuming a Custom API with React


      This tech talk will be streaming live on Thu, Jun 23, 2020 1:00 PM – 2:00 PM ET.
      RSVP for free on GotoWebinar here

      About the Talk

      We have built a custom API with Strapi in the past. Now that we have some data, a dashboard, and a REST API, let’s use JavaScript and React to consume that API.

      We will build a simple app and talk about grabbing data from our new API.

      Key takeaways

      • Building a Custom API with Strapi lets us focus on our frontend code
      • Using React to grab data from an API

      This talk is designed for

      Developers that have their own APIs and want to consume their APIs with React and JavaScript.

      Prerequisites

      Some knowledge of JavaScript and how APIs work is a plus.

      About the Presenter

      Chris Sevilleja (@chrisoncode) is the founder of scotch.io and Senior Developer Advocate at DigitalOcean. He loves trying to figure out the most efficient and practical way to build apps that we can ship to our customers.

      How to Join

      This tech talk is free and open to everyone. Join the live event on Thu, Jun 23, 2020 1:00 PM – 2:00 PM EDT by registering on GotoWebinar here and Chris will be answering questions at the end.

      If you can’t make the live event, the recording and transcript will be published here as soon as it’s available.





      Source link

      Cómo mostrar datos de la API de DigitalOcean con Django


      El autor seleccionó a Mozilla Foundation para recibir una donación como parte del programa Write for DOnations.

      Introducción

      A medida que continúa en aumento la demanda de desarrollo integral, los marcos web están haciendo que los flujos de trabajo de desarrollo sean menos complicados y más eficientes; Django es uno de esos marcos. Django se ha usado en sitios web importantes como Mozilla, Pinterest e Instagram. A diferencia de Flask, que es un micromarco neutral, el paquete PyPI de Django incluye todo lo que necesitaría para un desarrollo completo; sin necesidad de configurar una base de datos ni de controlar el panel para su desarrollo.

      Un caso de uso común para Django consiste en usarlo para mostrar información de las API (como publicaciones de Instagram o repositorios de GitHub) en sus aplicaciones y sitios web propios. Aunque esto es posible con otros marcos, la filosofía de “baterías incluidas” de Django implica que habrá menos problemas y se necesitarán menos paquetes para generar el mismo resultado.

      A través de este tutorial, creará un proyecto de Django que mostrará información del Droplet de su cuenta de DigitalOcean usando la API de DigitalOcean v2. En términos específicos, creará un sitio web que mostrará una tabla de Droplets listando cada ejemplar de sus direcciones IP, ID, regiones de hosting y recursos. Su sitio web usará BulmaCSS para dar estilo a la página, de modo que pueda concentrarse en el desarrollo y a la vez disponga de algo estético al final.

      Una vez completado este tutorial, dispondrá de un proyecto de Django que podrá producir una página web con el siguiente aspecto:

      Plantilla con tabla de datos del droplet

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      • Una cuenta de DigitalOcean con al menos un Droplet y un token de acceso personal. Asegúrese de registrar el token en un lugar seguro; lo necesitará más adelante en este tutorial.
      • Familiaridad al realizar solicitudes a API. Para ver un tutorial completo sobre cómo trabajar con API, consulte Cómo usar API web en Python3.
      • Un entorno virtual para Python para mantener dependencias. En este tutorial, usaremos el nombre do_django_api para el directorio de nuestro proyecto y env para nuestro entorno virtual.
      • Familiaridad con la lógica de plantillas de Django, para renderizar páginas con datos de API.
      • Familiaridad con la lógica de la vista de Django, para gestionar los datos recibidos de la API y proporcionarlos a una plantilla para su renderización.

      Paso 1: Crear un proyecto de Django básico

      Desde el entorno virtual env, instale Django:

      Ahora puede iniciar un proyecto de Django y ejecutar algunos comandos de configuración inicial.

      Utilice django-admin startproject <name> para crear en la carpeta del proyecto un subdirectorio que lleve el nombre del proyecto de Django. Luego posiciónese en ese directorio.

      • django-admin startproject do_django_project
      • cd do_django_project

      Una vez creado, dentro de este subdirectorio, encontrará manage.py, que es la alternativa habitual para interactuar con Django y ejecutar su proyecto. Utilice migrate para actualizar la base de datos de desarrollo de Django:

      • python3 manage.py migrate

      A medida que se actualice la base de datos, verá un resultado similar a este:

      Output

      Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions Running migrations: Applying contenttypes.0001_initial... OK Applying auth.0001_initial... OK Applying admin.0001_initial... OK Applying admin.0002_logentry_remove_auto_add... OK Applying admin.0003_logentry_add_action_flag_choices... OK Applying contenttypes.0002_remove_content_type_name... OK Applying auth.0002_alter_permission_name_max_length... OK Applying auth.0003_alter_user_email_max_length... OK Applying auth.0004_alter_user_username_opts... OK Applying auth.0005_alter_user_last_login_null... OK Applying auth.0006_require_contenttypes_0002... OK Applying auth.0007_alter_validators_add_error_messages... OK Applying auth.0008_alter_user_username_max_length... OK Applying auth.0009_alter_user_last_name_max_length... OK Applying auth.0010_alter_group_name_max_length... OK Applying auth.0011_update_proxy_permissions... OK Applying sessions.0001_initial... OK

      A continuación, utilice el comando runserver para ejecutar el proyecto de modo que pueda probarlo:

      • python3 manage.py runserver

      El resultado tendrá este aspecto cuando se inicie el servidor:

      Output

      Watching for file changes with StatReloader Performing system checks... System check identified no issues (0 silenced). September 22, 2019 - 22:57:07 Django version 2.2.5, using settings 'do_django_project.settings' Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C.

      Ahora, dispondrá de un proyecto de Django básico y un servidor de desarrollo activo. Para ver su servidor de desarrollo activo, visite 127.0.0.1:8000 en un navegador. Mostrará la página de inicio de Django:

      Página de inicio genérica de Django

      A continuación, creará una aplicación de Django y configurará su proyecto para ejecutar una vista desde dicha aplicación. Por lo tanto, verá algo más interesante que la página predeterminada.

      Paso 2: Crear una aplicación de Django básica

      En este paso, creará el esqueleto de la aplicación que contendrá los resultados de su Droplet. Volverá a esta aplicación más tarde, una vez que haya configurado la invocación de API para completarla con datos.

      Asegúrese de que estar posicionado en el directorio do_django_project y cree una aplicación de Django usando el siguiente comando:

      • python3 manage.py startapp display_droplets

      Ahora, deberá añadir la nueva aplicación a INSTALLED_APPS en el archivo settings.py, de modo que Django la reconozca. settings.py es un archivo de configuración de Django que se ubica dentro de otro subdirectorio en el proyecto de Django y tiene el mismo nombre que la carpeta del proyecto (do_django_project). Django creó ambas carpetas. Posiciónese en el directorio do_django_project:

      Modifique settings.py en el editor que prefiera:

      Añada su nueva aplicación a la sección INSTALLED_APPS del archivo:

      do_django_api/do_django_project/do_django_project/settings.py

      INSTALLED_APPS = [
          'django.contrib.admin',
          'django.contrib.auth',
          'django.contrib.contenttypes',
          'django.contrib.sessions',
          'django.contrib.messages',
          'django.contrib.staticfiles',
          # The new app
          'display_droplets',
      ]
      

      Guarde y cierre el archivo cuando termine.

      Función de visualización GetDroplets

      A continuación, creará una función, GetDroplets, dentro del archivo views.py de la aplicación de display_droplets. Esta función creará la plantilla que usará para mostrar datos del Droplet, como context, desde la API. context es un diccionario que se usa para tomar datos del código Python y eviarlos a una plantilla HTML para que pueda mostrarse en una página web.

      Posiciónese en el directorio display_droplets:

      • cd ..
      • cd display_droplets

      Abra views.py para editarlo:

      Añada el siguiente código al archivo:

      do_django_api/do_django_project/display_droplets/views.py

      from django.views.generic import TemplateView
      
      class GetDroplets(TemplateView):
          template_name = 'droplets.html'
          def get_context_data(self, *args, **kwargs):
              pass
      

      Guarde y cierre el archivo.

      Más adelante, completará esta función y creará el archivo droplets.html, pero primero configuraremos urls.py para invocar esta función cuando visite el directorio root del servidor de desarrollo (127.0.0.1:8000).

      Vuelva al directorio del proyecto do_django_project:

      • cd ..
      • cd do_django_project

      Abra urls.py para su editarlo:

      Añada la instrucción import para GetDroplets, y luego una ruta adicional para urlpatterns que apuntará a la nueva vista.

      do_django_api/do_django_project/do_django_project/urls.py

      from django.contrib import admin
      from django.urls import path
      from display_droplets.views import GetDroplets
      
      urlpatterns = [
          path('admin/', admin.site.urls),
          path('', GetDroplets.as_view(template_name='droplets.html'), name='Droplet View'),
      ]
      

      Si desea crear sus propias rutas personalizadas, el primer parámetro es la URL (como example.com/**admin**), el segundo es la función que se invocará para producir la página web y el tercero simplemente el nombre de la ruta.

      Guarde y cierre el archivo.

      Platilla de Droplets

      A continuación, trabajará con plantillas. Las plantillas son archivos HTML que Django usa para crear páginas web. En este caso, usará una plantilla para crear una página HTML que muestre los datos de la API.

      Vuelva al directorio display_droplets:

      • cd ..
      • cd display_droplets

      Dentro de este, cree la carpeta template y posicónese en ella:

      • mkdir templates
      • cd templates

      Cree droplets.html y ábralo para editarlo:

      Para evitar tener que escribir cualquier tipo de CSS para este proyecto, usaremos Bulma CSS porque es un marco CSS gratuito y ligero que le permite crear páginas web de aspecto limpio simplemente añadiendo algunos atributos de clase al HTML.

      Ahora, crearemos una plantilla con una barra de naevgación básica. Añada el siguiente código al archivo droplets.html.

      do_django_api/do_django_project/display_droplets/templates/droplets.html

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <meta charset="UTF-8">
          <title>DigitalOcean Droplets</title>
          <link crossorigin="anonymous"
                href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.7.4/css/bulma.min.css"
                integrity="sha256-8B1OaG0zT7uYA572S2xOxWACq9NXYPQ+U5kHPV1bJN4="
                rel="stylesheet"/>
          <link rel="shortcut icon" type="image/png" href="https://assets.digitalocean.com/logos/favicon.png"/>
      </head>
      <body>
      <nav aria-label="main navigation" class="navbar is-light" role="navigation">
          <div class="navbar-brand">
              <div class="navbar-item">
                  <img atl="DigitalOcean" src="https://assets.digitalocean.com/logos/DO_Logo_icon_blue.png"
                       style="margin-right: 0.5em;">Droplets
              </div>
          </div>
      </nav>
      </body>
      </html>
      

      Guarde y cierre el archivo.

      Este código importa Bulma a HTML estándar y crea la barra nav que muestra “Droplets”.

      Actualice la pestaña de su navegador para ver los cambios realizados en la plantilla.

      Plantilla con encabezado básico

      Hasta ahora, no intervino en nada relacionado con las API; creó una base para el proyecto. A continuación, pondrá en uso esta página creando una invocación de API y presentando los datos del Droplet.

      Paso 3: Crear la invocación de API

      En este paso, configurará una invocación de API y enviará los datos del Droplet como contexto para que la plantilla se muestre en una tabla.

      Obtener datos del Droplet

      Vuelva al directorio de la aplicación display_droplets:

      Instale la biblioteca requests para poder comunicarse con la API:

      La biblioteca requests permite que su código solicite datos de API y añada encabezados (datos adicionales enviados junto con nuestra solicitud).

      Ahora creará un archivo services.py, en el que realizará la invocación de la API. Esta función usará requests para comunicarse con https://api.digitalocean.com/v2/droplets y anexar cada Droplet en el archivo JSON devuelto a una lista.

      Abra services.py para editarlo:

      Añada el siguiente código al archivo:

      do_django_api/do_django_project/display_droplets/services.py

      import os
      import requests
      
      def get_droplets():
          url = 'https://api.digitalocean.com/v2/droplets'
          r = requests.get(url, headers={'Authorization':'Bearer %s' % 'access_token'})
          droplets = r.json()
          droplet_list = []
          for i in range(len(droplets['droplets'])):
              droplet_list.append(droplets['droplets'][i])
          return droplet_list
      

      Dentro de la función get_droplets pueden suceder dos cosas: se realiza una solicitud y se analizan los datos. url contiene los datos de la URL que solicita el Droplet de la API de DigitalOcean. r almacena los datos solicitados.

      requests toma dos parámetros en este caso: url y headers. Si desea datos de una API diferente, sustituirá el valor de url por la URL apropiada. headers envía a DigitalOcean su token de acceso a fin de que la plataforma verifique que tiene permiso para hacer la solicitud y confirme la cuenta para la cual se realiza la solicitud.

      droplets contiene la información de la variable r, pero ahora se convirtió a partir de JSON, el formato en el que cual API envía la información, en un diccionario fácil de usar en un bucle for.

      Con las siguientes tres líneas se crea una matriz, droplet_list[]​​​​. A continuación, un bucle for itera la información de los droplets y añade cada elemento a la lista. Toda la información tomada del API y almacenada en los droplets puede encontrarse en los documentos del desarrollador de DigitalOcean.

      Nota: No olvide sustituir access.token por su token de acceso. Además, guárdelo en un sitio seguro y nunca publique ese token en línea.

      Guarde y cierre el archivo.

      Proteger su token de acceso

      Siempre debería ocultar su token de acceso, pero si alguna vez alguien quisiera usar su proyecto, debería disponer de una alternativa sencilla para que esa persona pueda añadir su propio token de acceso sin tener que editar el código Python. DotENV es la solución, ya que las variables se guardan en un archivo .env que puede editarse de forma conveniente.

      Vuelva al directorio do_django_project.

      Para comenzar a trabajar con las variables de entorno, instale python-dotenv:

      • pip install python-dotenv

      Una vez que lo haga, deberá configurar Django para gestionar las variables de entorno de modo que pueda hacer referencia a ellas en el código. Para hacer eso, deberá añadir algunas líneas de código a manage.py y wsgi.py.

      Abra manage.py para editarlo:

      Añada el siguiente código:

      do_django_api/do_django_project/manage.py

      
      """Django's command-line utility for administrative tasks."""
      import os
      import sys
      import dotenv
      
      def main():
          os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'do_django_project.settings')
          try:
              from django.core.management import execute_from_command_line
          except ImportError as exc:
              raise ImportError(
                  "Couldn't import Django. Are you sure it's installed and "
                  "available on your PYTHONPATH environment variable? Did you "
                  "forget to activate a virtual environment?"
              ) from exc
          execute_from_command_line(sys.argv)
      
      if __name__ == '__main__':
          main()
      
      dotenv.load_dotenv(
          os.path.join(os.path.dirname(__file__), '.env')
      )
      

      Añadir esto en manage.py significa que cuando emita comandos a Django durante el desarrollo, gestionará las variables de entorno de su archivo .env.

      Guarde y cierre el archivo.

      Si alguna vez debe gestionar variables de entorno en sus proyectos de producción, podrá hacerlo desde el archivo wsgi.py. Posiciónese en el directorio do_django_project:

      Abra wsgi.py para su edición:

      Añada el siguiente código a wsgi.py:

      do_django_api/do_django_project/do_django_project/wsgi.py

      
      import os
      import dotenv
      
      from django.core.wsgi import get_wsgi_application
      
      os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'do_django_project.settings')
      
      dotenv.load_dotenv(
          os.path.join(os.path.dirname(os.path.dirname(__file__)), '.env')
      )
      
      application = get_wsgi_application()
      

      Este snippet de código tiene un os.path.dirname() adicional porque wsgi.py debe revisar nuevamente dos directorios para encontrar el archivo .env. Este snippet no es el mismo que se usa para manage.py.

      Guarde y cierre el archivo.

      Ahora puede usar una variable de entorno en services.py en vez de su token de acceso. Vuelva al directorio display_droplets:

      • cd ..
      • cd display_droplets

      Abra services.py para editarlo:

      Ahora sustituya su token de acceso por una variable de entorno.

      do_django_api/display_droplets/services.py

      import os
      import requests
      
      def get_droplets():
          url = "https://api.digitalocean.com/v2/droplets"
          r = requests.get(url, headers={'Authorization':'Bearer %s' % os.getenv('DO_ACCESS_TOKEN')})
          droplets = r.json()
          droplet_list = []
          for i in range(len(droplets['droplets'])):
              droplet_list.append(droplets['droplets'][i])
          return droplet_list
      

      Guarde y cierre el archivo.

      El siguiente paso es crear un archivo .env. Vuelva al directorio do_django_project:

      Cree un archivo .env y abra el archivo para editarlo:

      En .env, añada su token como la variable DO_ACCESS_TOKEN:

      do_django_api/do_django_project/.env

      DO_ACCESS_TOKEN=access_token
      

      Guarde y cierre el archivo.

      Nota: Añada .env a su archivo .gitignore para que nunca se incluya en sus ejecuciones.

      Con esto, configuró la conexión de la API y también protegió su token de acceso. Es el momento de presentar la información obtenida al usuario.

      Paso 4: Manipular datos del Droplet en vistas y plantillas

      Ahora que puede hacer invocaciones de API, deberá enviar los datos del Droplet a la plantilla para su representación. Regresaremos al módulo de la función, GetDroplets, que creó antes en views.py. En la función, enviará droplet_list como contexto a la plantilla droplets.html.

      Posiciónese en el directorio display_droplets:

      Abra views.py para editarlo:

      Añada el siguiente código a views.py:

      do_django_api/do_django_project/display_droplets/views.py

      from django.shortcuts import render
      from django.views.generic import TemplateView
      from .services import get_droplets
      
      class GetDroplets(TemplateView):
          template_name = 'droplets.html'
          def get_context_data(self, *args, **kwargs):
              context = {
                  'droplets' : get_droplets(),
              }
              return context
      

      La información enviada a la plantilla droplets.html se gestiona a través del diccionario context. Por eso, droplets funciona como clave y la matriz devuelta de get_droplets() como un valor.

      Guarde y cierre el archivo.

      Presentar los datos en la plantilla

      Dentro de la plantilla droplets.html, creará una tabla y la completará con los datos del Droplet.

      Posiciónese en el directorio templates:

      Abra droplets.html para editarlo:

      Añada el siguiente código después del elemento nav en droplets.html:

      do_django_api/do_django_project/display_droplets/templates/droplets.html

      <table class="table is-fullwidth is-striped is-bordered">
          <thead>
          <tr>
              <th>Name</th>
              <th>IPv4 Address(es)</th>
              <th>Id</th>
              <th>Region</th>
              <th>Memory</th>
              <th>CPUs</th>
              <th>Disk Size</th>
          </tr>
          </thead>
          <tbody>
          {% for droplet in droplets %}
          <tr>
              <th>{{ droplet.name }}</th>
              {% for ip in droplet.networks.v4 %}
              <td>{{ ip.ip_address }}</td>
              {% endfor %}
              <td>{{ droplet.id }}</td>
              <td>{{ droplet.region.name }}</td>
              <td>{{ droplet.memory }}</td>
              <td>{{ droplet.vcpus }}</td>
              <td>{{ droplet.disk }}</td>
          </tr>
          {% endfor %}
          </tbody>
      </table>
      

      {% for droplet in droplets %} ... {% endfor %} es un bucle que itera la matriz de Droplets recuperados de views.py. Cada Droplet se inserta en una fila de la tabla. Las diferentes líneas {{ droplet.<attribute> }}​​​ obtienen ese atributo para cada Droplet del bucle y lo insertan en una celda de tabla.​

      Guarde y cierre el archivo.

      Actualice su navegador para ver una lista de Droplets.

      Plantilla con tabla de datos de Droplets

      Ahora, podrá gestionar la API de DigitalOcean dentro de sus proyectos de Django. Tomó los datos obtenidos de la API y los incorporó a la plantilla que creó anteriormente, para mostrar la información de una forma legible y flexible.

      Conclusión

      A lo largo de este artículo, creó un proyecto de Django que puede mostrar información de Droplets de la API de DigitalOcean con estilo de CSS de Bulma. A través de este tutorial, aprendió tres habilidades importantes:

      • Gestión de solicitudes de API en Python usando los módulos requests y json.
      • Exposición de datos de API en un proyecto de Django usando la lógica de view y template.
      • Gestión segura de sus tokens de API usando dotenv en Django.

      Ahora que vio una introducción a la gestión de API en Django, puede crear un proyecto propio usando otra función de la API de DigitalOcean o una API diferente. También puede consultar otros tutoriales de Django o un tutorial similar con el marco React.





      Source link

      Como exibir dados da API da DigitalOcean com o Django


      O autor selecionou a Mozilla Foundation para receber uma doação como parte do programa Write for DOnations.

      Introdução

      Como a demanda por um desenvolvimento full-stack continua crescendo, os frameworks Web estão tornando os fluxos de trabalho menos trabalhosos e mais eficientes; o Django é um desses frameworks. O Django vem sendo usado em sites bastante conhecidos como o Mozilla, o Pinterest e o Instagram. Ao contrário do Flask, que é um microframework neutro, o pacote PyPI do Django inclui tudo o que você precisa para o desenvolvimento full-stack; não há necessidade de configurar um banco de dados ou um painel de controle para o desenvolvimento.

      Um uso comum para o Django é usá-lo para exibir informações de APIs (como os posts do Instagram ou os repositórios do GitHub) em seus próprios sites e aplicativos Web. Embora isso seja possível com outros frameworks, a filosofia do Django “baterias inclusas” significa que haverá menos problemas e menos pacotes necessários para criar o mesmo resultado.

      Neste tutorial, você criará um projeto Django que exibirá as informações do Droplet da sua conta da DigitalOcean usando a DigitalOcean v2 API. Especificamente, você criará um site que exibirá uma tabela de Droplets listando cada um dos endereços IP, IDs, regiões de hospedagem e recursos. Seu site usará o BulmaCSS para estilizar a página, para que você possa se concentrar no desenvolvimento, ao mesmo tempo que proporciona algo bonito para se ver no final.

      Assim que terminar este tutorial, você terá um projeto Django que consegue produzir uma página Web parecida com esta:

      Modelo com a tabela de dados do Droplet

      Pré-requisitos

      Antes de iniciar este guia, será necessário o seguinte:

      • Uma conta da DigitalOcean com pelo menos um Droplet e um token de acesso pessoal. Certifique-se de gravar o token em um lugar seguro; você precisará dele mais tarde neste tutorial.
      • Estar familiarizado com a criação de solicitações a APIs. Para um tutorial compreensivo sobre como trabalhar com APIs, consulte Como usar as APIs Web em Python3.
      • Um ambiente virtual local para o Python, para manter as dependências. Neste tutorial, usaremos o nome do_django_api para nosso diretório de projeto e env para o nosso ambiente virtual.
      • Estar familiarizado com a lógica de modelos do Django para renderizar páginas com dados de API.
      • Estar familiarizado com a lógica de visualização do Django para o processamento dos dados recebidos da API e fornecimento deles a um modelo para renderização.

      Passo 1 — Criando um projeto Django básico

      Do ambiente virtual env, instale o Django:

      Agora, você pode iniciar um projeto Django e executar alguns comandos de configuração inicial.

      Use django-admin startproject <name> para criar um subdiretório na pasta do projeto nomeada com base no seu projeto Django e, em seguida, mude para aquele diretório.

      • django-admin startproject do_django_project
      • cd do_django_project

      Assim que ele for criado, dentro deste subdiretório, você encontrará o manage.py, que é a maneira usual de interagir com o Django e executar seu projeto. Use migrate para atualizar o banco de dados de desenvolvimento do Django:

      • python3 manage.py migrate

      Você verá um resultado que se parece com este após a atualização do banco de dados:

      Output

      Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions Running migrations: Applying contenttypes.0001_initial... OK Applying auth.0001_initial... OK Applying admin.0001_initial... OK Applying admin.0002_logentry_remove_auto_add... OK Applying admin.0003_logentry_add_action_flag_choices... OK Applying contenttypes.0002_remove_content_type_name... OK Applying auth.0002_alter_permission_name_max_length... OK Applying auth.0003_alter_user_email_max_length... OK Applying auth.0004_alter_user_username_opts... OK Applying auth.0005_alter_user_last_login_null... OK Applying auth.0006_require_contenttypes_0002... OK Applying auth.0007_alter_validators_add_error_messages... OK Applying auth.0008_alter_user_username_max_length... OK Applying auth.0009_alter_user_last_name_max_length... OK Applying auth.0010_alter_group_name_max_length... OK Applying auth.0011_update_proxy_permissions... OK Applying sessions.0001_initial... OK

      Em seguida, utilize o comando runserver para executar o projeto, para que você possa testá-lo:

      • python3 manage.py runserver

      Quando o servidor for iniciado, o resultado se parecerá com este:

      Output

      Watching for file changes with StatReloader Performing system checks... System check identified no issues (0 silenced). September 22, 2019 - 22:57:07 Django version 2.2.5, using settings 'do_django_project.settings' Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C.

      Agora, você tem um projeto Django básico e um servidor de desenvolvimento em funcionamento. Para visualizar seu servidor de desenvolvimento em funcionamento, visite o 127.0.0.1:8000 em um navegador. Ele exibirá a página inicial do Django:

      Página inicial genérica do Django

      Em seguida, você criará um app do Django e configurará seu projeto para executar uma visualização a partir do app, para que você veja algo mais interessante que a página padrão.

      Passo 2 — Criando um aplicativo Django básico

      Neste passo, você criará o esqueleto do app que terá os resultados do seu Droplet. Mais tarde, você voltará para este aplicativo assim que tiver configurado a chamada de API para preenchê-lo com dados.

      Certifique-se de estar no diretório do_django_project e crie um app Django usando o seguinte comando:

      • python3 manage.py startapp display_droplets

      Agora, você precisa adicionar o novo app a INSTALLED_APPS no arquivo settings.py, para o Django reconhecê-lo. O settings.py é um arquivo de configuração do Django que está localizado dentro de outro subdiretório no projeto Django e tem o mesmo nome que a pasta do projeto (do_django_project). O Django criou ambas as pastas para você. Vá até o diretório do_django_project:

      Edite o settings.py no editor da sua escolha:

      Adicione seu novo app à seção INSTALLED_APPS do arquivo:

      do_django_api/do_django_project/do_django_project/settings.py

      INSTALLED_APPS = [
          'django.contrib.admin',
          'django.contrib.auth',
          'django.contrib.contenttypes',
          'django.contrib.sessions',
          'django.contrib.messages',
          'django.contrib.staticfiles',
          # The new app
          'display_droplets',
      ]
      

      Salve e feche o arquivo quando terminar.

      Função de visualização GetDroplets

      Em seguida, você criará uma função, GetDroplets, dentro do arquivo views.py do app display_droplets. Essa função renderizará o modelo que você usará para exibir os dados do Droplet, como o context, a partir da API. O context é um dicionário que é usado para tirar os dados do código do Python e enviá-los para um modelo HTML, para que ele possa ser exibido em uma página Web.

      Vá até o diretório display_droplets:

      • cd ..
      • cd display_droplets

      Abra o views.py​​​ para edição:

      Adicione o código a seguir ao arquivo:

      do_django_api/do_django_project/display_droplets/views.py

      from django.views.generic import TemplateView
      
      class GetDroplets(TemplateView):
          template_name = 'droplets.html'
          def get_context_data(self, *args, **kwargs):
              pass
      

      Salve e feche o arquivo.

      Mais tarde, você preencherá essa função e criará o arquivo droplets.html, mas primeiro vamos configurar o urls.py para chamar essa função quando você visitar o diretório raiz do servidor de desenvolvimento (127.0.0.1:8000).

      Volte para o diretório do_django_project:

      • cd ..
      • cd do_django_project

      Abra o urls.py​​​ para edição:

      Adicione uma instrução import para o GetDroplets e, em seguida, adicione um caminho adicional para o urlpatterns que apontará para a nova visualização.

      do_django_api/do_django_project/do_django_project/urls.py

      from django.contrib import admin
      from django.urls import path
      from display_droplets.views import GetDroplets
      
      urlpatterns = [
          path('admin/', admin.site.urls),
          path('', GetDroplets.as_view(template_name='droplets.html'), name='Droplet View'),
      ]
      

      Se quiser fazer seus próprios caminhos personalizados, o primeiro parâmetro é o URL (tal como example.com/**admin**), o segundo parâmetro é a função a ser chamada para produzir a página Web e o terceiro é apenas um nome para o caminho.

      Salve e feche o arquivo.

      Modelo de Droplets

      Em seguida, você trabalhará com os modelos. Os modelos são arquivos HTML que o Django usa para criar páginas Web. Neste caso, você usará um modelo para construir uma página HTML que exibe os dados da API.

      Volte para o diretório display_droplets:

      • cd ..
      • cd display_droplets

      Dentro deste diretório, crie uma pasta template (modelo) e vá para esse diretório:

      • mkdir templates
      • cd templates

      Crie o droplets.html e abra-o para edição:

      Para evitar que você tenha que escrever qualquer tipo de CSS para este projeto, usaremos o Bulma CSS, pois é um framework CSS leve e gratuito que permite que você crie páginas Web de aparência limpa, apenas adicionando alguns atributos de classe ao HTML.

      Agora, vamos criar um modelo com uma barra de navegação básica. Adicione o código a seguir ao arquivo droplets.html:

      do_django_api/do_django_project/display_droplets/templates/droplets.html

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <meta charset="UTF-8">
          <title>DigitalOcean Droplets</title>
          <link crossorigin="anonymous"
                href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.7.4/css/bulma.min.css"
                integrity="sha256-8B1OaG0zT7uYA572S2xOxWACq9NXYPQ+U5kHPV1bJN4="
                rel="stylesheet"/>
          <link rel="shortcut icon" type="image/png" href="https://assets.digitalocean.com/logos/favicon.png"/>
      </head>
      <body>
      <nav aria-label="main navigation" class="navbar is-light" role="navigation">
          <div class="navbar-brand">
              <div class="navbar-item">
                  <img atl="DigitalOcean" src="https://assets.digitalocean.com/logos/DO_Logo_icon_blue.png"
                       style="margin-right: 0.5em;">Droplets
              </div>
          </div>
      </nav>
      </body>
      </html>
      

      Salve e feche o arquivo.

      Esse código importa o Bulma para o HTML boilerplate e cria uma barra nav que exibe “Droplets”.

      Recarregue sua aba do navegador para visualizar as alterações que você fez no modelo.

      Modelo com o cabeçalho básico

      Até agora, você ainda não mexeu em nada relacionado às APIs; você criou uma fundação para o projeto. Em seguida, essa página será posta em uso, fazendo uma chamada de API e apresentando os dados do Droplet.

      Passo 3 — Fazendo a chamada de API

      Neste passo, você configurará uma chamada de API e enviará os dados do Droplet como contexto para o modelo exibir em uma tabela.

      Como obter dados do Droplet

      Navegue novamente para o diretório do app display_droplets:

      Instale a biblioteca requests (solicitações) para que você possa falar com a API:

      A biblioteca requests permite que seu código solicite dados de APIs e adicione cabeçalhos (dados adicionais enviados juntamente com nossa solicitação).

      Em seguida, você criará um arquivo services.py, que é onde fará a chamada API. Essa função usará requests para falar com https://api.ddigitalocean.com/v2/droplets e adicionará a uma lista cada Droplet presente no arquivo JSON retornado.

      Abra o services.py​​​ para edição:

      Adicione o código a seguir ao arquivo:

      do_django_api/do_django_project/display_droplets/services.py

      import os
      import requests
      
      def get_droplets():
          url = 'https://api.digitalocean.com/v2/droplets'
          r = requests.get(url, headers={'Authorization':'Bearer %s' % 'access_token'})
          droplets = r.json()
          droplet_list = []
          for i in range(len(droplets['droplets'])):
              droplet_list.append(droplets['droplets'][i])
          return droplet_list
      

      Dentro da função get_droplets, duas coisas ocorrem: uma solicitação é feita e os dados são analisados. O url contém o URL que solicita os dados do Droplet da API da DigitalOcean. O r armazena os dados solicitados.

      requests necessita de dois parâmetros neste caso: o url e o headers. Se quiser dados de uma API diferente, você substituirá o valor url pelo URL apropriado. O headers envia seu token de acesso à DigitalOcean, para que eles saibam que você tem permissão para fazer a solicitação e para qual conta a solicitação está sendo feita.

      Os droplets contêm a informação da variável r, mas agora ela foi convertida de JSON, o formato em que a API envia informações, para um dicionário que é fácil de usar em um loop for.

      As três linhas seguintes criam uma matriz, droplet_list[]. Em seguida, um loop for itera sobre as informações em droplets e adiciona cada item à lista. Todas as informações obtidas da API e armazenadas em droplets podem ser encontradas nos Docs de desenvolvedor da DigitalOcean.

      Nota: não se esqueça de substituir o access_token pelo seu token de acesso. Além disso, mantenha-o seguro e nunca publique esse token na internet.

      Salve e feche o arquivo.

      Como proteger seu token de acesso

      Você sempre deve esconder seu token de acesso, mas se alguém quiser executar seu projeto, deve haver uma maneira fácil para que eles adicionem seu próprio token de acesso sem precisar editar o código Python. O DotENV é a solução, já que as variáveis são mantidas em um arquivo .env que pode ser convenientemente editado.

      Volte para o diretório do_django_project:

      Para começar a trabalhar com variáveis de ambiente, instale o python-dotenv:

      • pip install python-dotenv

      Assim que estiver instalado, é necessário configurar o Django para lidar com variáveis de ambiente, de forma que você possa referenciá-las em código. Para fazer isso, é preciso adicionar algumas linhas de código em manage.py e wsgi.py.

      Abra o manage.py​​​ para edição:

      Adicione as linhas a seguir:

      do_django_api/do_django_project/manage.py

      
      """Django's command-line utility for administrative tasks."""
      import os
      import sys
      import dotenv
      
      def main():
          os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'do_django_project.settings')
          try:
              from django.core.management import execute_from_command_line
          except ImportError as exc:
              raise ImportError(
                  "Couldn't import Django. Are you sure it's installed and "
                  "available on your PYTHONPATH environment variable? Did you "
                  "forget to activate a virtual environment?"
              ) from exc
          execute_from_command_line(sys.argv)
      
      if __name__ == '__main__':
          main()
      
      dotenv.load_dotenv(
          os.path.join(os.path.dirname(__file__), '.env')
      )
      

      Adicionar isso em manage.py significa que, quando você emitir comandos para o Django em desenvolvimento, ele processará as variáveis de ambiente do seu arquivo .env.

      Salve e feche o arquivo.

      Se precisar lidar com variáveis de ambiente em seus projetos de produção, faça isso a partir do arquivo wsgi.py. Vá até o diretório do_django_project:

      E abra o wsgi.py​​ para edição:

      Adicione o código a seguir ao wsgi.py:

      do_django_api/do_django_project/do_django_project/wsgi.py

      
      import os
      import dotenv
      
      from django.core.wsgi import get_wsgi_application
      
      os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'do_django_project.settings')
      
      dotenv.load_dotenv(
          os.path.join(os.path.dirname(os.path.dirname(__file__)), '.env')
      )
      
      application = get_wsgi_application()
      

      Este fragmento de código tem um os.path.dirname() adicional, pois o wsgi.py precisa procurar dois diretórios para encontrar o arquivo .env. Este fragmento não é o mesmo que foi usado para o manage.py.

      Salve e feche o arquivo.

      Agora, você pode utilizar uma variável de ambiente em services.py em vez do seu token de acesso. Volte para o diretório display_droplets:

      • cd ..
      • cd display_droplets

      Abra o services.py​​​ para edição:

      Agora, substitua seu token de acesso por uma variável de ambiente:

      do_django_api/display_droplets/services.py

      import os
      import requests
      
      def get_droplets():
          url = "https://api.digitalocean.com/v2/droplets"
          r = requests.get(url, headers={'Authorization':'Bearer %s' % os.getenv('DO_ACCESS_TOKEN')})
          droplets = r.json()
          droplet_list = []
          for i in range(len(droplets['droplets'])):
              droplet_list.append(droplets['droplets'][i])
          return droplet_list
      

      Salve e feche o arquivo.

      O próximo passo é criar um arquivo .env. Volte para o diretório do_django_project:

      Crie um arquivo .env e entre no arquivo para edição:

      No .env, adicione seu token como a variável DO_ACCESS_TOKEN:

      do_django_api/do_django_project/.env

      DO_ACCESS_TOKEN=access_token
      

      Salve e feche o arquivo.

      Nota: adicione .env ao seu arquivo .gitignore, de modo que ele nunca seja incluído em suas confirmações.

      A conexão de API agora está definida e configurada, e você também protegeu seu token de acesso. É hora de apresentar para o usuário as informações que você recuperou.

      Passo 4 — Habilitando dados do Droplet em visualizações e modelos

      Agora que pode fazer as chamadas de API, você precisa enviar os dados do Droplet ao modelo para renderização. Vamos retornar ao stub da função, GetDroplets, que você criou antes em views.py. Na função, será enviado o droplet_list como contexto para o modelo droplets.html

      Vá até o diretório display_droplets:

      Abra o views.py​​​ para edição:

      Adicione o código a seguir ao views.py:

      do_django_api/do_django_project/display_droplets/views.py

      from django.shortcuts import render
      from django.views.generic import TemplateView
      from .services import get_droplets
      
      class GetDroplets(TemplateView):
          template_name = 'droplets.html'
          def get_context_data(self, *args, **kwargs):
              context = {
                  'droplets' : get_droplets(),
              }
              return context
      

      As informações enviadas para o modelo droplets.html são processadas por meio do dicionário context. Por isso, o droplets age como uma chave e a matriz retornada de get_droplets() age como um valor.

      Salve e feche o arquivo.

      Como exibir os dados no modelo

      Dentro do modelo droplets.html, você criará uma tabela e a preencherá com os dados do droplet.

      Vá até o diretório templates:

      Abra o droplets.html​​​ para edição:

      Adicione o código a seguir após o elemento nav em droplets.html:

      do_django_api/do_django_project/display_droplets/templates/droplets.html

      <table class="table is-fullwidth is-striped is-bordered">
          <thead>
          <tr>
              <th>Name</th>
              <th>IPv4 Address(es)</th>
              <th>Id</th>
              <th>Region</th>
              <th>Memory</th>
              <th>CPUs</th>
              <th>Disk Size</th>
          </tr>
          </thead>
          <tbody>
          {% for droplet in droplets %}
          <tr>
              <th>{{ droplet.name }}</th>
              {% for ip in droplet.networks.v4 %}
              <td>{{ ip.ip_address }}</td>
              {% endfor %}
              <td>{{ droplet.id }}</td>
              <td>{{ droplet.region.name }}</td>
              <td>{{ droplet.memory }}</td>
              <td>{{ droplet.vcpus }}</td>
              <td>{{ droplet.disk }}</td>
          </tr>
          {% endfor %}
          </tbody>
      </table>
      

      {% for droplet in droplets %} ... {% endfor %} é um loop que itera através da matriz de Droplets recuperados de views.py. Cada Droplet é inserido em uma linha de tabela. As várias linhas {{ droplet.<Attribute>}} recuperam o atributo para cada Droplet no loop e o inserem em uma célula da tabela.

      Salve e feche o arquivo.

      Recarregue o navegador e você verá uma lista de Droplets.

      Modelo com a tabela de dados do Droplet

      Agora, é possível lidar com a API da DigitalOcean dentro dos seus projetos do Django. Você pegou os dados recuperados da API e anexou-os no modelo que criou anteriormente, para exibir as informações de uma maneira legível e flexível.

      Conclusão

      Neste artigo, você construiu um projeto Django que exibe as informações do Droplet na API da DigitalOcean com a estilização do Bulma CSS. Você aprendeu três habilidades importantes seguindo este tutorial:

      • Como lidar com solicitações de API em Python, usando os módulos requests e json.
      • Como exibir dados de API em um projeto Django usando as lógicas view e template.
      • Como lidar com segurança com seus tokens de API usando o dotenv no Django.

      Agora que você foi introduzido ao processamento das APIs no Django, é possível criar um projeto próprio usando outra funcionalidade da API da DigitalOcean ou de uma outra API completamente diferente. Também é possível verificar outros tutoriais do Django ou um tutorial semelhante com o framework React.





      Source link