Autenticando para comandos REST

A maneira como você se autentica para executar comandos REST depende de como o servidor está configurado e da ferramenta que você está usando para executar os comandos.
Nota: O uso de comandos REST requer as mesmas permissões que o uso da interface da web. Para obter informações sobre permissões, consulte Roles and permissions.

Autenticando com um nome de usuário e senha

A maneira mais simples de autenticar para comandos REST é usar um nome de usuário e uma senha. Por exemplo, se você estiver usando o programa curl, será possível especificar o nome de usuário e a senha no comando, como no código a seguir:
curl -k -u jsmith:passwd
  https://myserver.example.com:8443/cli/application/info
  ?application=JPetStore

Autenticando com uma chave de sessão

Alguns clientes requerem uma chave de sessão para se conectar ao servidor. Para usar uma chave de sessão, deve-se efetuar login no servidor como de costume. Em seguida, você recupera a chave de sessão a partir de sua sessão com o servidor e usa essa chave de sessão em outras ferramentas.

Para recuperar uma chave de sessão, efetue login no servidor como de costume. Em seguida, no navegador da web, localize o valor do cabeçalho que é denominado UCD_SESSION_KEY. É possível procurar pelo cookie com esse nome ou consultar a lista de cabeçalhos que estão associados à página da web. A maneira como você visualiza essas informações depende de qual navegador você está usando. Consulte a documentação para seu navegador da web para obter informações adicionais.

Em seguida, é possível usar essa chave de sessão para autenticar-se para comandos REST. Por exemplo, você pode incluir o seguinte cabeçalho na solicitação:
UCD_SESSION_KEY:sessionKey
Use o valor do cookie UCD_SESSION_KEY como sessionKey.

Autenticando em scripts e programas

Muitas linguagens de programação e script podem chamar comandos REST.
O exemplo a seguir é um script Python que autentica incluindo a senha no cabeçalho da solicitação.
#!/usr/bin/env python

import urllib2
import json
import base64
import sys

if not len(sys.argv) == 3:
  print 'usage: script <username> <password>'
  exit(1)

username = sys.argv[1]
password = sys.argv[2]

epass = base64.b64encode(username + ':' + password)
print 'base64 encoded: ' + epass
baseUrl = 'ucdeploy.example.org:8443'

url = 'https://' + baseUrl + '/cli/application/info' + '?application=JPetStore'

opener = urllib2.build_opener(urllib2.HTTPHandler)
req = urllib2.Request(url)
req.add_header('Authorization', 'Basic '+epass)
req.get_method = lambda: 'GET'

resp = opener.open(req)
print resp.read()

Autenticando em um script Groovy

Para obter um exemplo de autenticação em um script Groovy, consulte a página a seguir: http://devblog.laraziosi.org/extensibility/index.php/devops-articles/6-getting-started-with-the-ibm-urbancode-deploy-rest-api-and-groovy

Autenticando em uma classe Java

O código Java™ a seguir é um exemplo simples de autenticação com um nome de usuário e senha. O código aceita todos os certificados, mas é possível modificar o código para controlar quais certificados são aceitos.

Este exemplo requer os arquivos JAR HttpComponents-Util.jar e uDeployRestClient.jar. O arquivo HttpComponents-Util.jar está disponível na pasta opt no servidor. O arquivo uDeployRestClient.jar está disponível em vários plug-ins principais, como o plug-in UrbanCode Deploy Applications.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.log4j.Logger;

import com.urbancode.commons.httpcomponentsutil.HttpClientBuilder;

public class RESTExample {

  public static void main(String[] args) {

  // suppress log4j messages from UCD library
  Logger.getRootLogger().setLevel(org.apache.log4j.Level.OFF);

  HttpClientBuilder clientBuilder = new HttpClientBuilder();
  clientBuilder.setUsername("admin");
  clientBuilder.setPassword("admin");

  // for SSL enabled servers, accept all certificates
  clientBuilder.setTrustAllCerts(true); 
  DefaultHttpClient client = clientBuilder.buildClient();

  try {
    HttpGet request = new HttpGet(new URI(
      "https://ucdeploy.example.org:8443/cli/application/info?application=JPetStore"));

    try {
      HttpResponseresp = client.execute(request);
      BufferedReaderbr = new BufferedReader ( 
        new InputStreamReader(resp.getEntity().getContent()));

      String currentLine = new String();
      while ((currentLine = br.readLine()) != null){
        System.out.print(currentLine);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  } catch (URISyntaxException e) {
    e.printStackTrace();
  }

  }

}

Importando o certificado do servidor

O certificado do servidor padrão não é assinado. Algumas ferramentas não se conectam a servidores com certificados não assinados por padrão. Para acessar um servidor com um certificado autoassinado, é possível instruir a ferramenta a conectar-se de forma insegura, ou você pode importar o certificado em seu cliente. Siga estas etapas para importar o certificado em seu cliente:
  1. Exporte o certificado do servidor para um arquivo:
    1. No computador que hospeda o servidor IBM® UrbanCode Deploy, abra o arquivo server.xml em um editor de texto. Por padrão, esse arquivo está no local server_install/opt/tomcat/conf/server.xml. The default server installation directory is /opt/ibm-ucd/server on Linux and C:\Program Files\ibm-ucd\server on Windows.
    2. No arquivo server.xml, localize as seguintes linhas de código e anote os valores dos atributos keystoreFile e keystorePass:
      sslProtocol="TLS"
      keystoreFile="conf/tomcat.keystore"
      keystorePass="changeit" />
    3. Em uma janela de linha de comandos, execute o comando a seguir:
      keytool -v -list -keystore keyStoreFileName
      Use o nome do atributo keystoreFile do arquivo server.xml para keyStoreFileName. Quando o comando solicitar uma senha, especifique o valor do atributo keystorePass. O valor padrão é changeit.
    4. A partir do resultado do comando, localize o alias do servidor. Por exemplo, o resultado do comando pode ser semelhante ao código a seguir:
      Keystore type: JKS
      Keystore provider: SUN
      
      Your keystore contains 1 entry
      
      Alias name: server
      Creation date: Mar 19, 2014
      Entry type: PrivateKeyEntry
      Neste código, o alias é server.
    5. Execute o comando a seguir para exportar o certificado para um arquivo e especificar a senha novamente:
      keytool -exportcert 
        -alias serverAlias 
        -keystore keyStoreFileName 
        -storetype jks 
        -file server.cert
      Use o alias do servidor para serverAlias.
  2. Copie o arquivo server.cert no computador cliente.
  3. Importe o arquivo server.cert no keystore do computador cliente:
    1. Em uma janela de linha de comandos no computador cliente, execute o comando a seguir e especifique a senha para o keystore no cliente. O padrão é changeit.
      jreLocation\jre\bin\keytool.exe -importcert 
        -alias serverAlias
        -file tomcat.cert 
        -storetype jks 
        -keystore jreLocation\jre\lib\security\cacerts
      Use o local do JRE ou JDK para jreLocation.
Agora, algumas ferramentas que usam esse JRE ou JDK aceitam o certificado do servidor. Outras ferramentas, como curl, podem ainda não aceitar o certificado do servidor porque ele não está assinado. Para resolver esse problema, configure um certificado assinado para o servidor.

Feedback