Caderno de práticas

Tecnologias Inovadoras de Rede – UNIBRATEC
Caderno de Práticas
Prof.: João Bosco Teixeira Junior
v0.4 29/08/2015
INTRODUÇÃO
Esse caderno tem o objetivo de agregar um conjunto de práticas que permitirá ao aluno verificar
alguns conceitos relacionados a Web das Coisas.
Lista de Práticas
1 – Atualizando uma planilha no google drive usando a API Temboo
2 – Ajustando o Apache para Tratar as URIs
3 – Construindo uma Aplicação RESTful para IoT
Pratica 1 – Atualizando uma planilha no Google Drive
O objetivo deste laboratório é mostrar como usar a biblioteca TEMBOO para mandar dados a uma
planilha no google drive. Os passos a seguir levam em consideração que você possui conta nestes
dois serviços. Caso não tenha, por favor crie.
TEMBOO: www.temboo.com
Nova conta GOOGLE: https://accounts.google.com/NewAccount
Passo 1: Criar uma conta de aplicação no google.
OBS: Essa conta é diferente da conta de e-mail.
Acesse o site https://console.developers.google.com/
Após o login, se você não tiver nenhum projeto você deve receber uma tela como essa:
Clique na opção Criar um projeto vazio.
Digite um nome para o projeto e pressione o botão criar.
Uma tela mostrando o status da criação será mostrada. Espere a conclusão, conforme a tela acima.
Após esse procedimento deverá aparecer um menu lateral. Escolha o menu API e Autenticação.
Em seguida escolha a opção credenciais. A tela seguinte deve aparecer:
Pressione o botão adicionar credenciais. Escolha a opção ID do Cliente OAUTH 2.0.
Em seguida escolha a opção Configurar tela de consentimento. Na tela seguinte só precisa
preencher um nome para o Projeto. O resto pode ficar em branco. Pressione o botão OK.
Na tela seguinte preencha os seguintes dados (USERX é o usuário que você criou no temboo):
Escolha a opção Aplicativo da WEB.
Origens JavaScript autorizadas: https://USERX.temboolive.com
URIs de redirecionamento autorizados: https://USERX.temboolive.com/callback/google
Clique no botão Criar;
Ao final deste procedimento será gerada uma tela com o id do cliente OAUTH e chave secreta.
Abra um editor de textos e copie essas informações.
Passo 2: Cria a planilha no google.
Acesse o google drive e crie uma nova planilha com o nome ACESSOS.
Preencha as três primeiras células da linha 1 com DATA, HORA e COMODO respectivamente.
Passo 3: Criar a coreografia no serviço temboo.
Em uma nova aba, faça login no serviço TEMBOO. Após isso clique no link LIBRARY no canto
superior direito da página.
Deve aparecer do lado esquerdo todas as bibliotecas suportadas pelo serviço.
Passo 3.1: Inicio da Configuração da Autenticação
Procure na listagem google e a expanda. Outras sub opções devem aparecer. Escolha OAuth –>
InitializeOAuth
Agora deve aparecer uma tela como a seguinte:
Preencha o campo cliente ID com o valor informado na tela de credenciais de aplicações do Google
Developers Console (https://console.developers.google.com/). Cuidado com os espaços antes e
depois do ID.
O campo escopo determina o que a credencial terá acessos na API do google e deve ser preenchido
com os seguintes valores separados por espaço (copie e cole no formulário):
https://spreadsheets.google.com/feeds/
https://docs.googleusercontent.com/
https://docs.google.com/feeds/
Quando todos os campos estiverem preenchidos você pode clicar no botão RUN.
Essa ação gerará duas saidas AutorizationURL e Callbackid.
A AutorizationURL deve ser acessada para que o usuário possa explicitamente permitir o acesso a
API do google. Desta forma copie o campo e abra uma nova janela com a URL em questão.
Ao acessar a AutorizationURL você receberá uma mensagem informando que seu projeto gostaria
de: Visualizar e Gerenciar suas Planilhas no Google Drive e Visualizar e Gerenciar qualquer
um de seus documentos no Google Drive.
Clique em Aceitar. Assim que você obtiver a tela branca você poderá avançar para o próximo
passo.
Passo 3.2: Finalizando a Configuração de Autenticação
Para essa configuração você precisará do CallBackid gerado no passo anterior, sendo assim copie-o
para a área de transferência.
Procure na listagem de bibliotecas google e a expanda. As sub opções devem aparecer. Escolha
OAuth –> FinalizeOAuth, Abra em uma nova aba, você deve receber a seguinte tela:
Preencha as informações. ClientID e ClientSecret devem ser obtidos da tela de credenciais de
aplicações do Google Developers Console (https://console.developers.google.com/). O CallbackID
é o que você copiou do passo anterior. Depois de preenchido o formulário pressione RUN.
Após a execução deste procedimento será gerado o AccessToken e o RefreshToken, ambos serão
usados no próximo passo desta configuração.
Passo 3.3: Configurando a tarefa
Neste ultimo passo vamos usar os tokens de autenticação gerados no passo anterior e configurar a
tarefa de atualizar uma planilha do google drive.
Procure na listagem de bibliotecas google e a expanda. As sub opções devem aparecer. Escolha
Spreadsheets –> AppendRow, abra em uma nova aba , você deve receber uma tela com os
seguintes campos, preencha conforme as orientações:
ClientID: deixe em branco
ClientSecret: deixe em branco
RefreshToken: Copie da tela do passo anterior
RowData: 29-08-2014 , 20:00, SALA 1
SpreadsheetTitle: ACESSOS
Expanda para mostrar as entradas opcionais (OPTIONAL INPUT)
AccessToken: Copie da tela do passo anterior.
SheetName: Deixe em branco
Depois de preenchido tecle em RUN.
Se tudo correr bem o campo de saída Response terá o valor success.
Passo 3.4: Testando a configuração.
Abaixo do campo de saída response existe uma seção chamada CODE. Através de um COMBO do
lado direito é possível escolher o tipo de código que será gerado, escolha cURL
Copie e linha gerada e cole no terminal do Linux. Execute o comando e observe se a planilha está
sendo atualizada.
Pratica 2 – Ajustando o Apache para Tratar as URIs
O Apache já possui nativamente a capacidade de tratar URIs, sendo que estas, no contexto do
serviço web tradicional dizem respeito a objetos existentes no disco do equipamento onde o
servidor Web está instalado. Esses objetos podem ser arquivos html, scripts para gerar conteúdo
dinâmico ou ainda arquivos de aplicação, como figuras e documentos (PDF, DOC, XLS, etc).
Disso isso, precisamos modificar a configuração do servidor web, de forma a repassar as
requisições de URI feitas pelos clientes.
Sendo assim, o objetivo desta prática é fazer um servidor apache responder a requisições do tipo
REST. Sendo assim vamos editar as configurações do apache para permitir a rescrita da URIs que
chegam ao servidor web para encaminhamento a aplicação que vai tratar as Requisições.
Passo 0: Configuração da VM e Preparação do Ambiente
Configure a máquina virtual (O disco será fornecido em sala) com REDE em modo Bridge em
seguida inicie a VM.
Ao fim do boot a máquina virtual estará pronta para login: (Login: root senha: 123456)
Após o login você receberá um prompt de comando onde você poderá digitar a sequencia de
comandos:
#
Verifique a interface que começa com eth:
# ifconfig -a
Ative a placa de Rede (onde X é número da sua placa de rede)
# dhclient ethX
Agora Verifique o IP
# ifconfig ethX
Em seguida inicie o servidor web Apache
# service httpd start
Abra um browser no host (maquina real) e acesse o IP da maquina virtual. Se não vier a página de
boas vindas do CentOS reveja o passos a seguir.
Se funcionar passe para o próximo passo.
Passo 1: Configurações da apache
Edite o arquivo /etc/httpd/conf/httpd.conf
# nano /etc/httpd/conf/httpd.conf
Procure a diretiva AllowOverride None na linha 338 (use o ctrl + < - > para ir para a linha ) e troque
para:
AllowOverride All
Para gravar o arquivo use ctr + < x > seguido de < s > e <enter>.
Agora edite o arquivo /etc/httpd/conf.d/welcome.conf
# nano /etc/httpd/conf.d/welcome.conf
E comente todas as linhas deixando o arquivo com o seguinte aspecto:
#
# This configuration file enables the default "Welcome"
# page if there is no default index page present for
# the root URL. To disable the Welcome page, comment
# out all the lines below.
#
#<LocationMatch "^/+$">
# Options -Indexes
# ErrorDocument 403 /error/noindex.html
#</LocationMatch>
Reinicie o servidor web:
service httpd restart
Configure o servidor web para iniciar junto com o SO:
chkconfig httpd on
Passo 2: Configuração do Redirecionamento
Vamos criar uma pasta para a nossa api no diretório raiz do apache:
# mkdir /var/www/html/api
Agora vamos criar o arquivo .htaccess:
# nano /var/www/html/api/.htaccess
Deixe o arquivo com a seguinte aparência:
Options -Indexes
RewriteEngine on
RewriteRule ^/* /server.php
Vamos criar um arquivo de teste para testar o redirecionamento:
#nano /var/www/html/server.php
digite o seguinte texto:
<?php
phpinfo();
?>
Agora abra um navegador e acesse o servidor web da VM usando o browser da Máquina Real.
http://IP_VM/api/cpu
Qualquer valor que seja colocado após a pasta api na URI, será redirecionado para o server.php
entretando a URI no browser permancerá inalterada.
Pratica 3 – Construindo uma Aplicação RESTful para IoT
O objetivo desta prática é construir uma aplicação RESTful que fornecerá informações de um
sistema computacional, no nosso exemplo informações da cpu. E também permitirá a criação de um
arquivo com o conteúdo passado via API.
A API para aplicação será da seguinte forma:
Método
URI
DADO
Descrição
GET
/api/cpu
NULL
Gera na saída o arquivo
de CPU do sistema
PUT
/api/arquivos [ {"nome":"nomearquivo" }, {"conteudo":"dado" } ]
Cria um arquivo no tmp do
sistema com o nome
nomearquivo e conteúdo
dado
Dito tudo isso vamos iniciar a criação da aplicação.
Passo 1: Agora vamos editar server.php em /var/www/html para capturar as requisições.
<?php
$uri=$_SERVER['REQUEST_URI'];
//variavel de ambiente que guarda a uri solicita
$metodo=$_SERVER['REQUEST_METHOD']; //variavel de ambiente que guarda o metodo
$caminho=explode('/', $uri);
//transforma a uri em um array
echo "$uri\n";
//exibe na saida a URI
echo "$metodo\n";
//exibe na saida metodo passado
print_r($caminho);
//exibe o array caminho
echo "\n";
//imprime um enter
//INSIRA O PROXIMO CODIGO AQUI
?>
Agora vamos testar as requisições usando o aplicativo curl. Esse aplicativo é um cliente web
altamente customizável. A sua sintaxe básica é:
Sintaxe: curl -v -X METODO URI -d dado
Vamos testar a resposta do servidor.
# curl -v -X PUT http://127.0.0.1/api/cpu
A resposta deve ser parecida com esta:
/api/cpu
PUT
Array
(
[0] =>
[1] => api
[2] => cpu
)
Passo 2: Tratamento das Requisições
O próximo passo é colocar código de controle que vai tratar cada um dos métodos (GET, PUT,
DELETE, OPTIONS) para isso insira as linhas no arquivo server.php no local indicado.
switch($metodo) {
case 'PUT':
echo "TRATAR PUT\n";
break;
case 'DELETE':
echo "TRATAR DELETE\n";
break;
case 'GET':
echo "TRATAR GET\n";
break;
case 'OPTIONS':
echo "GET, PUT, DELETE, OPTIONS\n";
break;
default:
header('HTTP/1.1 405 Method Not Allowed');
header('Allow: GET, PUT, DELETE, OPTIONS');
break;
}
Vamos testar a resposta do servidor para as diferentes metodos:
# curl -v -X PUT http://127.0.0.1/api/cpu
ou :
# curl -v -X OPTIONS http://127.0.0.1/api/cpu
Passo 3: Tratando as URIs (Somente o GET)
Observe array abaixo, veja que o elemento que queremos tratar (cpu) está no indice 2 do array:
Array
(
[0] =>
[1] => api
[2] => cpu
)
Vamos alterar o código (incluir as linhas em vermelho e remover as linhas em negrito):
<?php
$uri=$_SERVER['REQUEST_URI'];
//variavel de ambiente que guarda a uri solicita
$metodo=$_SERVER['REQUEST_METHOD']; //variavel de ambiente que guarda o metodo
$caminho=explode('/', $uri);
//transforma a uri em um array
echo "$uri\n";
//exibe na pagina a URI
echo "$metodo\n";
//exibe o metodo passado
print_r($caminho);
//exibe o array caminho
echo "\n";
//imprime um enter
$elemento=$caminho[2];
//Guarda o elemento da requisição
switch($metodo){
case 'PUT':
echo "TRATAR PUT\n";
break;
case 'DELETE':
echo "TRATAR DELETE\n";
break;
case 'GET':
echo "TRATAR GET\n";
//Remover essa linha
fun_get($elemento);
//chama o tratamento de GET
break;
case 'OPTIONS':
echo "GET, PUT, DELETE, OPTIONS\n";
break;
default:
header('HTTP/1.1 405 Method Not Allowed');
header('Allow: GET, PUT, DELETE, OPTIONS');
break;
}
function fun_get($elem){
//funcao que trata requisicoes GET
if ( $elem == 'cpu' ){
//se o elemento for CPU
system('/bin/cat /proc/cpuinfo'); //imprime informacoes de CPU do sistema
}
else{
header('HTTP/1.1 404 Not Found');
}
}
//INSIRA O PROXIMO CODIGO AQUI
?>
Teste o funcionamento do script:
# curl -v -X OPTIONS http://127.0.0.1/api/cpu
Teste com outro objeto:
# curl -v -X OPTIONS http://127.0.0.1/api/cpu
Exercício: Insira a MEMORIA como novo elemento para tratamento do sistema. Ou seja,
uma requisição do tipo:
# curl -v -X OPTIONS http://127.0.0.1/api/mem
Deve retornar as informações de memória do sistema:
Dica: as informações de memória estão no arquivo /proc/meminfo
Passo 4: Enviando dados para tratamento
Digamos que agora vamos enviar para aplicação um comando para criar um arquivo no servidor.
A requisição será da seguinte forma:
Metodo: PUT
Dado: [ {"nome":"nomearquivo" }, {"conteudo":"dado" } ]
Exemplo de requisição:
# curl -v -X PUT http://127.0.0.1/api/arquivo -d '[ {"nome":"teste.txt" }, {"conteudo":"TESTE REST" } ]'
Após essa requisição ser enviada, no sistema será criado um arquivo em /tmp/teste.txt com o
conteúdo TESTE REST.
Vamos agora alterar o código o primeiro passo é capturar o dado dentro da aplicação: para isso
vamos usar a função file_get_contents('php://input') alterando o código de tratamento do PUT,
localize o código (insira as linha em vermelho e remova as linhas em negrito):
case 'PUT':
echo "TRATAR PUT\n"; //Remover esse linha
$dado = file_get_contents('php://input');
if (is_null($dado)) {
header('HTTP/1.1 400 Bad Request');
}
else{
$array_dado = json_decode($dado);
print_r($array_dado);
}
break;
//captura o dado vindo da requisicao
//se nao tiver dado a requisicao é
//invalida
//imprime os dados da requisicao
Agora você pode testar o servidor usando o comando:
# curl -v -X PUT http://127.0.0.1/api/arquivo -d '[ {"nome":"teste.txt" }, {"conteudo":"TESTE REST" } ]'
Na saída do comando deve ser mostrado o array dado, conforme abaixo:
Array
(
[0] => stdClass Object
(
[nome] => teste.txt
)
[1] => stdClass Object
(
[conteudo] => TESTE REST
)
)
Para finalizar vamos criar a função que vai processar a requisição:
case 'PUT':
$dado = file_get_contents('php://input');
if (is_null($dado)) {
header('HTTP/1.1 400 Bad Request');
}
else{
$array_dado = json_decode($dado);
print_r($array_dado);
fun_put($elemento, $array_dado);
}
break;
//captura o dado vindo da requisicao
//se nao tiver dado a requisicao é
//invalida
//remover essa linha
Agora insira o código da função fun_post();
function fun_put($elem, $data){
//funcao que trata requisicoes PUT
$nomearq = $data[0]->{'nome'};
$conteudo = $data[1]->{'conteudo'};
if ( $elem == 'arquivo' ){
//se o elemento for arquivo
system("/bin/echo $conteudo > /tmp/$nomearq");
}
else{
header('HTTP/1.1 404 Not Found');
}
}
Agora você pode testar a aplicação servidor:
# curl -v -X PUT http://127.0.0.1/api/arquivo -d [ {"nome":"teste.txt" }, {"conteudo":"TESTE REST" } ]
Agora verifique se foi criado um arquivo /tmp/teste.txt e veja o seu conteúdo:
# cat /tmp/teste.txt
A resposta deve ser TESTE REST.