Exposing Your API in Drupal 8

Video loading...

  • 0:02
    Exposing Your API in Drupal 8 Blake Hall
  • 0:04
    In this lesson,
  • 0:05
    we're going to take a look at how Drupal 8
  • 0:06
    can help us quickly expose a REST API.
  • 0:09
    We'll do this by enabling and configuring the REST module
  • 0:12
    and the REST UI module from Contrib.
  • 0:16
    We'll also take a look at a high level overview
  • 0:18
    of how an API is created and served by Core in Drupal 8
  • 0:22
    and by the end of the video,
  • 0:23
    you'll understand how the components in these four modules
  • 0:25
    contribute to providing an out of the box API
  • 0:28
    without writing a single line of code.
  • 0:30
    We'll again be making heavy use of
  • 0:31
    the Postman Chrome extension.
  • 0:33
    So if you don't already have that installed,
  • 0:35
    you might want to do so.
  • 0:36
    Let's get started.
  • 0:38
    The first thing we want to do,
  • 0:39
    in addition to downloading Drupal 8 Core,
  • 0:41
    is to download the REST UI module.
  • 0:43
    The REST UI module will allow us to
  • 0:45
    configure our API endpoints
  • 0:47
    without having to dig in YAML files to do so.
  • 0:50
    Here, we're looking at a fresh installation of Drupal 8
  • 0:52
    along with the REST UI module.
  • 0:54
    Let's log in and get started.
  • 0:56
    Now that we're logged in, first things first,
  • 0:58
    we need to enable a few modules.
  • 0:59
    We'll go to the extend page.
  • 1:02
    We can find the REST modules down
  • 1:03
    at the bottom of the page.
  • 1:05
    We're going to want to enable HAL,
  • 1:07
    HTTP Basic Authentication, REST UI,
  • 1:10
    RESTful Web Services, and Serialization.
  • 1:13
    While we're waiting for those modules to install,
  • 1:15
    let's take a look at how these moving pieces fit together.
  • 1:18
    This graphic is from a presentation done by Lin Clark,
  • 1:21
    from DrupalCon Prague in 2013.
  • 1:23
    It describes the basic pipeline for
  • 1:25
    REST responses in Drupal 8.
  • 1:27
    If we trace an incoming request,
  • 1:29
    we can see that it's routed to the RequestHandler.
  • 1:31
    The RequestHandler identifies that the REST module
  • 1:34
    is responsible for this request
  • 1:36
    and sends it to the deserializer to normalize the data.
  • 1:39
    The RequestHandler then matches up the request
  • 1:41
    with the appropriate ResourceHandler.
  • 1:43
    We'll take a look at an example of those
  • 1:45
    from Core in a little while.
  • 1:46
    This resource plugin takes the data
  • 1:49
    from the incoming request
  • 1:50
    and retrieves the relevant information from
  • 1:52
    the database or elsewhere.
  • 1:54
    When the resource plugin returns data to the RequestHandler,
  • 1:56
    it again interacts with the serializer
  • 1:58
    before being sent along as a response.
  • 2:01
    The modules included in Core that we just enabled
  • 2:03
    will handle serialization for
  • 2:05
    XML, JSON, and HAL + JSON.
  • 2:08
    It's probably not surprising
  • 2:09
    that the serialization module is responsible
  • 2:11
    for deserializing and serializing
  • 2:13
    request and response data.
  • 2:15
    The HAL module specifically provides a
  • 2:17
    HAL+JSON serialization plugin.
  • 2:19
    The HTTP Basic Authentication module provides
  • 2:22
    an authentication plugin, which allows
  • 2:24
    us to control access to our API resources
  • 2:26
    based on HTTP method.
  • 2:28
    There will likely be other authentication mechanisms
  • 2:31
    such as OAuth, supported in the future via contrib modules.
  • 2:34
    The RESTful Web Services module handles the
  • 2:36
    resource plugin system as well as
  • 2:38
    defining the initial resource routes.
  • 2:40
    A good example of a resource plugin
  • 2:42
    can be found in the dblog module,
  • 2:44
    which provides an API endpoint for watchdog entries.
  • 2:47
    REST UI, which we took a look at,
  • 2:49
    is a super helpful Contrib module
  • 2:51
    which exposes our RESTful Web Services configuration
  • 2:54
    via the admin UI.
  • 2:55
    So we can configure our API endpoints without
  • 2:57
    editing YAML files.
  • 2:59
    Now that we have all of our modules labeled,
  • 3:01
    let's take a look at that configuration screen.
  • 3:03
    We'll go to Configuration.
  • 3:05
    Scrolling down under Services,
  • 3:07
    we'll see a REST item.
  • 3:09
    Here's the list of resources provided to us
  • 3:11
    by the RESTful Web Services module.
  • 3:14
    For now, let's just look at the Content resource.
  • 3:16
    When I click Edit, I'm taken to a configuration page
  • 3:18
    where I can select which HTTP verbs
  • 3:21
    this API should respond to,
  • 3:23
    as well as which formats and which authentication methods
  • 3:26
    we should work with for each verb.
  • 3:30
    Once we're happy with how we've configured our API,
  • 3:32
    let's jump over to the permissions page
  • 3:34
    to get permissions setup as well.
  • 3:36
    Scrolling down, we can see that several
  • 3:38
    new permissions have been added by the
  • 3:40
    REST Web Services module.
  • 3:42
    For each type of resource we've enabled,
  • 3:44
    we're able to specify which Drupal roles
  • 3:46
    can access a particular HTTP verb.
  • 3:48
    This means we can open our API
  • 3:50
    to get requests from anonymous users
  • 3:52
    and at the same time, we can restrict
  • 3:54
    POST, PATCH, and DELETE operations to administrators.
  • 3:58
    Now that we've got our permissions in order,
  • 3:59
    let's try making a few requests to our new API.
  • 4:03
    Of course, before we can make requests to our new API,
  • 4:06
    we need to create some content.
  • 4:08
    Let's just create a simple page node.
  • 4:10
    We could also use Devel generate to
  • 4:12
    generate sample content for our site.
  • 4:14
    After saving our page node,
  • 4:16
    or generating some sample content,
  • 4:18
    we can switch over to Postman to make a
  • 4:19
    request against our new API.
  • 4:21
    The URL we need to hit to access our content endpoint
  • 4:24
    is node/1 and then add
  • 4:26
    a query parameter for the format
  • 4:28
    we're interested in retrieving.
  • 4:30
    In this case, let's grab HAL JSON.
  • 4:32
    If we submit that GET request,
  • 4:33
    our API will respond back with a HAL JSON
  • 4:36
    representation of that node.
  • 4:38
    It's worth emphasizing here that we've included
  • 4:40
    the request format as a query parameter.
  • 4:42
    If we'd rather retrieve XML or just straight JSON,
  • 4:45
    we can simply tweak this query paramater
  • 4:47
    to receive the desired format.
  • 4:49
    Let's see what node/1 looks like as an XML representation.
  • 4:53
    We could also set up our authorization header here
  • 4:55
    to pass our Drupal credentials along to our API request.
  • 4:58
    This will allow us to make authenticated requests
  • 5:00
    to do things like post nodes.
  • 5:02
    Let's give that a shot.
  • 5:04
    In order to post a new content resource,
  • 5:06
    we need to change this endpoint to be entity/node.
  • 5:12
    We also need to set our basic authentication header
  • 5:15
    using our Drupal username and password.
  • 5:18
    Then, we'll set the content type header
  • 5:20
    so Drupal knows to accept HAL+JSON.
  • 5:25
    We'll switch our HTTP verb to POST
  • 5:29
    and then we're going to paste in some raw post data.
  • 5:31
    This is a little bit obtuse,
  • 5:33
    but what we're doing is specifying a link type here
  • 5:36
    so Drupal knows exactly which entity type, a node,
  • 5:39
    and which bundle, an article, that we're trying to create.
  • 5:42
    After that, we provide values for
  • 5:44
    the title field and the body field
  • 5:47
    and we're ready to post our data.
  • 5:49
    Let's go ahead and send this request.
  • 5:52
    To post a node to our Drupal 8 site,
  • 5:54
    we're going to need to use a new API endpoint
  • 5:57
    and, I apologize for this,
  • 5:59
    but a new version of the Postman extension as well.
  • 6:02
    The endpoint we're going to hit is
  • 6:03
    newblog.local/entity/node.
  • 6:06
    We're going to need to add basic authentication here
  • 6:08
    since only authenticated users are
  • 6:10
    able to make POST requests.
  • 6:12
    So we'll enter in our username and password
  • 6:14
    and click update request.
  • 6:16
    Taking a look at the headers
  • 6:17
    that Postman's going to add to our request,
  • 6:19
    we can see 2.
  • 6:20
    First, there's the content type,
  • 6:22
    where we're specifying the
  • 6:23
    type of data we're going to be posting to Drupal.
  • 6:25
    In this case, HAL+JSON.
  • 6:27
    There's also an authorization header that's been added.
  • 6:30
    This was created automatically for us
  • 6:32
    when we entered in our authorization
  • 6:34
    information on the previous tab.
  • 6:36
    Then, in the body field,
  • 6:37
    we're going to paste in the raw JSON
  • 6:39
    we wish to post to Drupal.
  • 6:41
    This is a little bit obtuse.
  • 6:43
    HAL+JSON's a little bit hard to type out.
  • 6:45
    But what we're doing here,
  • 6:46
    is we're specifying a link type.
  • 6:48
    So Drupal knows which entity type, a node,
  • 6:50
    and which bundle, an article, to create with our data.
  • 6:54
    After that, we provide values for the title and body
  • 6:57
    and we're ready to post.
  • 6:58
    We'll go ahead and click Send
  • 6:59
    and if everything goes as expected,
  • 7:01
    we should see a 201 Created response here.
  • 7:04
    If we look at the headers in the response,
  • 7:06
    the location we get gives us the URL for our new node.
  • 7:09
    In this case, node/53.
  • 7:13
    Back on our site, if we load node 53,
  • 7:15
    we can indeed see the test post that
  • 7:17
    we just created with Postman.
  • 7:19
    So far, we've seen it's easy to get and post data
  • 7:22
    from our Drupal 8 site,
  • 7:23
    but if we enable the Views module,
  • 7:25
    we can build an even more powerful API.
  • 7:28
    Let's build a new view.
  • 7:30
    We'll click on Structure and Views.
  • 7:33
    When we add a new view,
  • 7:35
    we're now given a new option
  • 7:37
    for a display type called REST export settings.
  • 7:40
    Let's create a new view called articles.
  • 7:43
    And we're going to show content of type Article,
  • 7:46
    sorted by Newest first,
  • 7:48
    and Provide a REST export path of api/articles.
  • 7:53
    I'll click Save and edit.
  • 7:55
    Since this is just a view with an extra display type,
  • 7:58
    it works like all of the other views you're familiar with
  • 8:01
    including support for contextual filters.
  • 8:03
    Let's build a quick view.
  • 8:04
    Instead of showing the full entity,
  • 8:06
    let's just show fields.
  • 8:08
    We're going to have the title.
  • 8:09
    Let's also add a summary field.
  • 8:15
    We're going to use the summary or trimmed formatter
  • 8:17
    and limit it to 600 characters and click apply.
  • 8:22
    We can see in the preview below
  • 8:23
    that we've just created a JSON response API
  • 8:26
    using views that will just list out the title and a teaser
  • 8:30
    for all of our article nodes without
  • 8:32
    writing a single line of code.
  • 8:33
    We'll go ahead and save this view
  • 8:35
    and then take a look at our api/articles
  • 8:37
    endpoint in Postman.
  • 8:38
    Back in Postman, we're going to make a GET request
  • 8:40
    to our new api/articles endpoint.
  • 8:44
    Here we can see an array being returned
  • 8:46
    with the title and body for
  • 8:47
    each one of our article nodes.
  • 8:49
    We just built a new API to export articles using views
  • 8:52
    and just clicking it together without
  • 8:54
    writing any code at all.
  • 8:55
    Pretty cool, huh?
  • 8:57
    To recap, in this lesson,
  • 8:58
    we took a look at how the modules included in Drupal 8 Core
  • 9:01
    along with the REST UI helper module
  • 9:03
    allow us to build a simple API
  • 9:05
    to expose content on our site
  • 9:07
    without writing a single line of code.
  • 9:09
    We also took a look at the REST pipeline in Drupal 8
  • 9:12
    and saw various points Drupal modules
  • 9:14
    can provide additional plugins to make our
  • 9:16
    API even more flexible.
  • 9:18
    I can imagine contrib modules will likely be written
  • 9:20
    to provide additional data export formats
  • 9:23
    as well as supporting additional resource types.
  • 9:25
    Drupal 8 truly makes it easy to start building
  • 9:27
    an API for your site.
  • 9:29
    So what are you waiting for?
  • 0:02
    Expondo Sua API no Drupal 8
  • 0:04
    Nessa lição,
  • 0:05
    iremos dar uma olhada em como o Drupal 8
  • 0:06
    pode nos ajudar a expor uma API REST rapidamente.
  • 0:09
    Iremos fazer isso habilitando e configurando o módulo REST
  • 0:12
    e o módulo REST UI, que são contribuídos.
  • 0:16
    Também iremos ter uma visão geral de alto nível
  • 0:18
    sobre como uma API é criada e servida pelo core no Drupal 8
  • 0:22
    e no final do vídeo,
  • 0:23
    você entenderá como os componentes nesses 4 módulos
  • 0:25
    contribuem para fornecer uma API nativa
  • 0:28
    sem escrever uma única linha de código.
  • 0:30
    Iremos, novamente, fazer uso pesado
  • 0:31
    da extensão Postman do Chrome.
  • 0:33
    Então se você não tem isso instalado,
  • 0:35
    você poderia fazer isso.
  • 0:36
    Vamos começar.
  • 0:38
    A primeira coisa que queremos fazer,
  • 0:39
    além de baixar o core do Drupal 8,
  • 0:41
    é baixar o módulo REST UI.
  • 0:43
    O módulo REST UI irá nos permitir
  • 0:45
    configurar nossos endpoints da API
  • 0:47
    sem ter que cavar em arquivos YAML para fazer isso.
  • 0:50
    Aqui, estamos olhando para uma instalação nova do Drupal 8
  • 0:52
    junto com o módulo REST UI.
  • 0:54
    Vamos entrar e começar.
  • 0:56
    Agora que já entramos, a primeira coisa,
  • 0:58
    precisamos habilitar alguns módulos.
  • 0:59
    Iremos para a página Extend.
  • 1:02
    Podemos encontrar os módulos REST
  • 1:03
    abaixo, na parte inferior da página.
  • 1:05
    Iremos querer habilitar HAL,
  • 1:07
    HTTP Basic Authentication, REST UI,
  • 1:10
    RESTful Web Services, e Serialization.
  • 1:13
    Enquanto estamos esperando para que esses módulos instalem,
  • 1:15
    vamos dar uma olhada como essas partes em movimento se juntam.
  • 1:18
    Esse gráfico é de uma apresentação feita por Lin Clark,
  • 1:21
    da DrupalCon Prague em 2013.
  • 1:23
    Ela descreve o pipeline básico
  • 1:25
    para respostas REST no Drupal 8.
  • 1:27
    Se rastrearmos uma requisição que está entrando,
  • 1:29
    podemos ver que ela é roteada para o RequestHandler.
  • 1:31
    O RequestHandler identifica que o módulo REST
  • 1:34
    é responsável por essa requisição
  • 1:36
    e ele envia ela para o deserializer para normalizar os dados.
  • 1:39
    O RequestHandler então corresponde a requisição
  • 1:41
    com o ResourceHandler apropriado.
  • 1:43
    Iremos dar uma olhada em um exemplo disso
  • 1:45
    no core daqui a pouco.
  • 1:46
    Esse plugin de recurso pega os dados
  • 1:49
    da requisição que está entrando
  • 1:50
    e retira as informações relevantes do
  • 1:52
    banco de dados ou de outro lugar.
  • 1:54
    Quando o plugin de recurso retorna dados para o RequestHandler,
  • 1:56
    ele novamente interage com o serializer
  • 1:58
    antes de ser enviado juntamente como uma reposta.
  • 2:01
    Os módulos incluídos no core que recém habilitamos
  • 2:03
    irão tomar conta da serialização
  • 2:05
    para XML, JSON, e HAL + JSON.
  • 2:08
    Provavelmente não é surpresa
  • 2:09
    que o módulo Serialization é responsável
  • 2:11
    pela serialização e deserialização
  • 2:13
    dos dados da requisição e resposta.
  • 2:15
    O módulo HAL, especificamente, fornece
  • 2:17
    um plugin de serialização HAL + JSON.
  • 2:19
    O módulo HTTP Basic Authentication fornece
  • 2:22
    um plugin de autenticação, que nos permite
  • 2:24
    controlar o acesso aos recursos da nossa API
  • 2:26
    baseados no método HTTP.
  • 2:28
    Provavelmente terão mecanismos de autenticação
  • 2:31
    como OAuth, suportados no futuro através de módulos contribuídos.
  • 2:34
    O módulo RESTful Web Services toma conta
  • 2:36
    do sistema de plugins de recurso bem como
  • 2:38
    define as rotas iniciais dos recursos.
  • 2:40
    Um bom exemplo de um plugin de recurso
  • 2:42
    pode ser encontrado no módulo dblog,
  • 2:44
    que fornece um endpoint de API para entradas do watchdog.
  • 2:47
    REST UI, que já vimos,
  • 2:49
    é um módulo contribuído super útil
  • 2:51
    que expõe nossa configuração RESTful Web Services
  • 2:54
    através da interface administrativa.
  • 2:55
    Então podemos configurar nossos endpoints da API sem
  • 2:57
    ter que editar arquivos YAML.
  • 2:59
    Agora que temos todos os nossos módulos rotulados,
  • 3:01
    vamos dar uma olhada na tela de configuração.
  • 3:03
    Iremos em Configuration,
  • 3:05
    rolando pra baixo até Services,
  • 3:07
    iremos ver o item REST.
  • 3:09
    Aqui é uma lista de recursos fornecidos para nós
  • 3:11
    pelo módulo RESTful Web Services.
  • 3:14
    Por enquanto, vamos apenas olhar apenas para o recurso Content.
  • 3:16
    Quando eu clico Edit, sou levado para uma página de configuração
  • 3:18
    onde posso selecionar quais verbos HTTP para
  • 3:21
    quais essa API deve responder,
  • 3:23
    bem como quais formatos e métodos de autenticação com os quais
  • 3:26
    iremos trabalhar para cada verbo.
  • 3:30
    Uma vez que estivermos satisfeitos com a maneira que configuramos nossa API,
  • 3:32
    vamos ir para a página de permissões
  • 3:34
    para configurar as permissões também.
  • 3:36
    Rolando para baixo, podemos ver que várias
  • 3:38
    permissões novas foram adicionadas pelo
  • 3:40
    módulo REST Web Services.
  • 3:42
    Para cada tipo de recurso que habilitamos,
  • 3:44
    podemos especificar quais papéis do Drupal
  • 3:46
    podem acessar certo verbo HTTP.
  • 3:48
    Isso significa que podemos abrir nossa API
  • 3:50
    para obter requisições de usuários anônimos
  • 3:52
    e ao mesmo tempo, podemos restringir
  • 3:54
    operações POST, PATCH e DELETE para administradores.
  • 3:58
    Agora que temos nossas permissões em ordem,
  • 3:59
    vamos tentar fazer algumas requisições para nossa nova API.
  • 4:03
    Claro, antes de podermos fazer requisições para nossa nova API,
  • 4:06
    precisamos criar alguns conteúdos.
  • 4:08
    Vamos criar um node de página simples.
  • 4:10
    Também poderíamos usar o Devel Generate para
  • 4:12
    gerar conteúdo de exemplo para nosso site.
  • 4:14
    Depois de salvar nosso node de página,
  • 4:16
    ou gerar conteúdo de exemplo,
  • 4:18
    podemos comutar para o Postman para
  • 4:19
    fazer uma requisição contra nossa nova API.
  • 4:21
    A URL que precisamos atingir para acessar nosso endpoint de conteúdo
  • 4:24
    é node/1 e depois adicionar
  • 4:26
    um parâmetro de consulta para o formato
  • 4:28
    que estamos interessados em buscar.
  • 4:30
    Nesse caso, vamos pegar HAL JSON.
  • 4:32
    Se submetermos essa requisição GET,
  • 4:33
    nossa API irá responder de volta com uma representação
  • 4:36
    HAL JSON desse node.
  • 4:38
    É importante enfatizar aqui que incluímos
  • 4:40
    o formato da requisição como parâmetro de consulta.
  • 4:42
    Se quiséssemos buscar um XML ou JSON diretamente,
  • 4:45
    podemos simplesmente configurar esse parâmetro de consulta
  • 4:47
    para receber o formato desejado.
  • 4:49
    Vamos ver com o que node/1 se parece como uma representação XML.
  • 4:53
    Também poderíamos configurar nosso cabeçalho da autorização aqui
  • 4:55
    para passar credenciais Drupal juntamente com nossa requisição de API.
  • 4:58
    Isso irá nos permitir fazer requisições autenticadas
  • 5:00
    para fazer coisas como postar nodes.
  • 5:02
    Vamos dar uma chance a isso.
  • 5:04
    Para poder postar novo conteúdo de recurso,
  • 5:06
    precisamos mudar esse endpoint para ser entity/node.
  • 5:12
    Também precisamos configurar nosso cabeçalho de autenticação básico
  • 5:15
    usando nosso nome de usuário e senha Drupal.
  • 5:18
    Depois, iremos definir o cabeçalho Content-Type
  • 5:20
    para que o Drupal saiba como aceitar HAL + JSON.
  • 5:25
    Vamos mudar nosso verbo HTTP para POST
  • 5:29
    e depois iremos colar alguns dados brutos do post.
  • 5:31
    Isso é um pouco obtuso,
  • 5:33
    mas o que estamos fazendo aqui é especificando um tipo de link aqui
  • 5:36
    para que o Drupal saiba exatamente qual tipo de entidade, um node,
  • 5:39
    e qual bundle, um article, que estamos tentando criar.
  • 5:42
    Depois disso, fornecemos valores para
  • 5:44
    o campo do título e o campo do corpo
  • 5:47
    e estamos prontos para postar nossos dados.
  • 5:49
    Vamos seguir em frente e enviar essa requisição.
  • 5:52
    Para postar um node no nosso site Drupal 8,
  • 5:54
    iremos precisar usar um novo endpoint de API
  • 5:57
    e, eu peço desculpas por isso,
  • 5:59
    mas uma nova versão da extensão Postman também.
  • 6:02
    O endpoint que iremos atingir
  • 6:03
    é newblog.local/entity/node.
  • 6:06
    Iremos precisar adicionar autenticação básica aqui
  • 6:08
    já que apenas usuários autenticados estão
  • 6:10
    aptos a fazer requisições POST.
  • 6:12
    Então iremos colocar nosso nome de usuário e senha
  • 6:14
    e clicar em Update request.
  • 6:16
    Olhando de volta para os cabeçalhos
  • 6:17
    que o Postman irá adicionar a nossa requisição
  • 6:19
    podemos ver 2.
  • 6:20
    Primeiramente, há o Content-Type,
  • 6:22
    onde estamos especificando
  • 6:23
    o tipo de dados que iremos postar no Drupal.
  • 6:25
    Nesse caso, HAL + JSON.
  • 6:27
    Também há um cabeçalho de autorização que foi adicionado.
  • 6:30
    Isso foi criado automaticamente para nós.
  • 6:32
    quanto colocamos nossas informações
  • 6:34
    de autorização na aba anterior.
  • 6:36
    Depois, no campo body,
  • 6:37
    iremos colar o JSON bruto
  • 6:39
    que queremos postar no Drupal.
  • 6:41
    Isso é um pouco obtuso.
  • 6:43
    HAL + JSON é um pouco difícil de digitar.
  • 6:45
    Mas o que estamos fazendo aqui,
  • 6:46
    é, estamos especificando um tipo de link.
  • 6:48
    Então o Drupal sabe qual tipo de entidade, um node,
  • 6:50
    e qual bundle, um article, para criar com nossos dados.
  • 6:54
    Depois disso, fornecemos valores para o title e body
  • 6:57
    e estamos prontos para postar.
  • 6:58
    Vamos seguir em frente e clicar em Send
  • 6:59
    e se tudo acontece como o esperado,
  • 7:01
    devemos ver uma resposta 201 Created aqui.
  • 7:04
    Se olharmos para os cabeçalhos na resposta,
  • 7:06
    a localização que obtemos nos dá a URL para nosso novo node.
  • 7:09
    Nesse caso, node/53.
  • 7:13
    De volta para nosso site, se carregarmos o node 53,
  • 7:15
    certamente podemos ver o post de teste
  • 7:17
    que acabamos de criar com o Postman.
  • 7:19
    Até agora, vimos que é fácil obter e postar dados
  • 7:22
    do nosso site Drupal 8,
  • 7:23
    mas se habilitarmos o módulo Views,
  • 7:25
    podemos construir uma API ainda mais poderosa.
  • 7:28
    Vamos contruir uma nova view.
  • 7:30
    Iremos clicar em Structure, e Views.
  • 7:33
    Quando adicionamos uma nova view,
  • 7:35
    é dada uma nova opção para nós,
  • 7:37
    para um display type chamado REST Export Settings.
  • 7:40
    Vamos criar uma nova view chamada articles.
  • 7:43
    E iremos mostrar conteúdo do tipo article,
  • 7:46
    classificado por mais novos primeiro,
  • 7:48
    e fornecer um caminho de exportação REST api/articles.
  • 7:53
    Irei clicar em Save and edit.
  • 7:55
    Já que isso é apenas uma view com um display type extra,
  • 7:58
    ela funciona assim como todas as outras views com quais você está familiar
  • 8:01
    incluindo suporte para filtros contextuais.
  • 8:03
    Vamos construir uma view rápida.
  • 8:04
    Ao invés de mostrar a entidade completa,
  • 8:06
    vamos mostrar apenas fields.
  • 8:08
    Iremos ter o title.
  • 8:09
    Vamos também adicionar um field de resumo.
  • 8:15
    Iremos usar o formatador summary or trimmed
  • 8:17
    e limitar isso em 600 caracteres e clicar em Apply.
  • 8:22
    Podemos ver na prévia abaixo
  • 8:23
    que acabamos de criar uma API de respostas JSON
  • 8:26
    usando views que irá apenas listar o título e o teaser
  • 8:30
    de todos nossos nodes article sem
  • 8:32
    escrever uma única linha de código.
  • 8:33
    Iremos prosseguir e salvar essa view
  • 8:35
    e depois dar uma olhada no nosso endpoint
  • 8:37
    api/articles no Postman.
  • 8:38
    De volta ao Postman, iremos fazer uma requisição GET
  • 8:40
    para nosso novo endpoint api/articles.
  • 8:44
    Aqui podemos ver um array sendo retornado
  • 8:46
    com o title e body para
  • 8:47
    cada um dos nossos nodes article.
  • 8:49
    Acabamos de construir uma nova API para exportar articles usando views
  • 8:52
    e apenas clicando, sem ter que
  • 8:54
    escrever nenhum código.
  • 8:55
    Muito legal, hein?
  • 8:57
    Para recapitular, nessa lição,
  • 8:58
    demos uma olhada em como módulos incluídos no core Drupal 8
  • 9:01
    juntamente com o módulo REST UI
  • 9:03
    nos permitem criar uma API simples
  • 9:05
    para expor conteúdo no nosso site
  • 9:07
    sem ter que escrever uma única linha de código.
  • 9:09
    Também vimos o pipeline REST no Drupal 8
  • 9:12
    e vimos vários pontos que módulos Drupal
  • 9:14
    podem fornecer plugins adicionais para
  • 9:16
    fazermos nossa API ainda mais flexível.
  • 9:18
    Eu posso imaginar que módulos contribuídos provavelmente serão escritos
  • 9:20
    para fornecer formatos adicionais de exportação de dados
  • 9:23
    bem como suportar tipos de recursos diferentes.
  • 9:25
    O Drupal 8 realmente faz com que seja fácil começar a contruir
  • 9:27
    uma API para seu site.
  • 9:29
    Então, o que você está esperando?

Decoupled Drupal

Loading ...

Exposing Your API in Drupal 8

Loading...

Core in Drupal 8 comes with a built-in solution for providing creating a REST API without writing a single line of code.

In this lesson we will talk about the core modules that help create a REST API, including:

  • REST module
  • Serializer
  • HAL
  • Basic Authentication
  • and the RESTUI contributed module

Self-check question: Can you find examples in Drupal core of plugins that expose data to the REST server?

Note: The video covers creating a node (via POST) twice, using two different versions of the Postman Chrome extension.

Downloads: 
Log in or sign up to download companion files.
Additional resources: 

Average review

4
Average: 4 (1 vote)

Reviews

4

Seems like an editing mistake during the "create node" part of the video where it shows an old version first, then jumps to the fixed version of the process. A little confusing, but easy enough to realize what happened.
Other than that, it was the perfect first time guide through the settings.