Como exibir modelos de machine learning usando Apigee e AI Platform

Veja neste tutorial como configurar a Apigee com o AI Platform Prediction.

Ao disponibilizar modelos de machine learning, a preparação de dados e o treinamento de modelos são apenas dois fatores a considerar. Você também precisa observar o seguinte:

  • Disponibilizar predições com escalonabilidade, desempenho e disponibilidade em mente.
  • Restringir acesso à funcionalidade, dependendo de quem o usuário é. Por exemplo, um usuário interno em sua empresa ou um usuário de uma organização parceira externa.
  • Impor cotas e políticas de uso usando chaves de API.
  • Gerenciar o ciclo de vida das chaves de API, especialmente na distribuição e na revogação.
  • Conceder acesso às APIs do ML por meio de um processo de aprovação manual ou automatizado.
  • Implementar novas versões do modelo à medida que os modelos de machine learning são atualizados.

O Google Cloud oferece serviços gerenciados de hospedagem de modelos e gerenciamento de APIs para acessar os recursos de previsão dos seus modelos hospedados.

O AI Platform é um serviço de machine learning gerenciado e escalonável disponível no Google Cloud. Além do treinamento usando a infraestrutura distribuída do Google, o AI Platform oferece hospedagem de modelos para exibir predições on-line e em lote. A infraestrutura subjacente aproveita o balanceamento de carga global do Google para oferecer predições de alto desempenho a usuários em todo o mundo.

Nos casos de uso de baixa latência, o serviço on-line do AI Platform permite fazer predições para seus modelos hospedados ao expor uma API REST que retorna predições diretamente na resposta. A infraestrutura de exibição para hospedar o modelo é dimensionada automaticamente de acordo com a demanda, sem precisar manter configurações complexas ou gerenciar o provisionamento de infraestrutura. O AI Platform também simplifica o processo de atualização de modelos de previsão ao fornecer recursos de controle de versões de modelos.

Para permitir recursos de gerenciamento de API mais abrangentes no seu serviço, use a predição on-line do AI Platform com a Apigee e ative:

  • políticas controle de acesso e segurança granulares para sua API;
  • análise de APIs para entender o uso;
  • limitação de taxa de APIs e outras restrições de cotas;
  • acesso de terceiros à API por meio de chaves de desenvolvedor;
  • monetização da sua API AI Platform hospedada na predição on-line do AI Platform;
  • alterações transparentes no modelo, direcionando as solicitações de predição por meio da fachada de uma API.

Objetivos

  • Implante proxies de API usando a Apigee para seus modelos hospedados no AI Platform.
  • Proteja o acesso aos modelos hospedados usando chaves de API.
  • Especificar processos de aprovação manuais e automáticos para distribuição de chaves de API.
  • Criar produtos de API para impor diferentes políticas de uso, como cotas baseadas em tempo de acordo com um tipo de inscrito.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem ser qualificados para uma avaliação gratuita.

Além dos componentes faturáveis do Google Cloud, neste tutorial usamos a Apigee.

Antes de começar

Criar um projeto do Google Cloud

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative a API AI Platform.

    Ative a API

Caso não tenha o SDK do Cloud instalado, use o Cloud Shell para implantar o aplicativo. O Cloud Shell oferece um ambiente de shell com o SDK do Cloud pré-instalado. No restante deste tutorial, usamos o Cloud Shell.

Criar uma conta do Apigee

Siga os passos em Como criar uma conta da Apigee. O Apigee fornece uma conta de avaliação sem custo para testar a solução e que pode ser usada para executar as etapas neste tutorial.

Arquitetura da solução

Neste tutorial, você implantará os modelos do TensorFlow no AI Platform e usará a predição on-line para disponibilizar a exibição deles. A Apigee fornece uma conta de avaliação sem custo para testar a solução e que pode ser usada para executar as etapas neste tutorial. Em seguida, a Apigee encaminhará as solicitações para a predição on-line do AI Platform. A Apigee aplicará políticas de API (como cotas de uso, limitação de taxa e verificação de chaves de API) e variações de políticas (como variações de cotas por chave de AP) por meio dos produtos de API que você configurar. O diagrama a seguir ilustra essa arquitetura.

Como implantar modelos do TensorFlow no AI Platform e usar a previsão on-line para disponibilizar a exibição deles

A tabela a seguir explica os conceitos do diagrama detalhadamente.

Conceito Descrição
Aplicativo Um aplicativo chama as predições em seu modelo de machine learning por meio de uma API hospedada no Apigee. A solicitação HTTP é feita para um endpoint gerenciado por um proxy de API. Na Apigee, o proxy de API executa a verificação de chaves de API para autenticação e aplica os níveis específicos de acesso e funcionalidade definidos pelo produto da API associado à chave de API.
Proxy de API Um proxy de API encaminha as solicitações de um endpoint de proxy (exposto para os aplicativos clientes) para um endpoint de destino. Esse é o endpoint de destino do seu modelo hospedado para solicitação de predições on-line do AI Platform.
Produto de API Um produto de API agrupa recursos do Apigee (como proxies de API) para fornecer um nível específico de acesso e funcionalidade para desenvolvedores de aplicativos clientes. Por exemplo, o produto de API pode impor limites de acesso, métodos de aprovação de chave de API e outras configurações para os proxies de API usados para acessar predições on-line em modelos hospedados.
Modelo hospedado Um modelo hospedado é um modelo de ML treinado e implantado no AI Platform. Para solicitar previsões dos seus modelos hospedados, use a previsão on-line e a previsão em lote do AI Platform.

Em vez de expor o modelo hospedado no AI Platform diretamente aos usuários, a arquitetura dessa solução usa a Apigee para permitir que usuários externos chamem modelos hospedados por meio de um proxy de API. Enviar solicitações por proxy pela Apigee permite a aplicação de políticas de uso diferentes.
Recursos do modelo Neste tutorial, para implantar um modelo hospedado do TensorFlow no AI Platform, exporte seu modelo no formato SavedModel do TensorFlow e armazene os recursos de modelo resultantes em um bucket do Cloud Storage. Em seguida, o serviço on-line ou em lote do AI Platform poderá fazer predições sobre o modelo.

Exemplo

Neste tutorial, você usa a Apigee para criar dois exemplos de produtos de API referente a um modelo hospedado simples (predição de renda a partir de dados do censo) implantado no AI Platform.

O diagrama a seguir explica os dois produtos de API de exemplo: um produto Income Prediction Trial com cotas de baixa utilização e um produto Income Prediction Premium com cotas elevadas. No cenário de exemplo, você registra dois desenvolvedores e aplicativos para testar a API sob diferentes restrições impostas pelos dois produtos de API.

Dois exemplos de produtos de API para um modelo hospedado simples implantado no AI Platform

Como criar uma conta de serviço do Google Cloud

O Apigee Edge precisa de uma conta de serviço do Google Cloud para autenticar as solicitações à previsão on-line do AI Platform.

GCLOUD

  1. Abra o Cloud Shell:

    ACESSAR o Cloud Shell

    Salvo indicação contrária, você usará o Cloud Shell em todo este tutorial.

  2. Configure uma variável de ambiente para o nome de sua conta de serviço:

    SERVICE_ACCOUNT=income-prediction-api@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com
    
  3. Crie uma conta de serviço:

    gcloud iam service-accounts create \
        income-prediction-api \
        --display-name "Apigee service account"
    
  4. Crie uma chave privada para a conta de serviço:

    gcloud iam service-accounts keys create \
        --iam-account ${SERVICE_ACCOUNT} \
        ~/key.json
    

    Esse comando salva um arquivo de chave privada em ${HOME}/key.json. Mantenha esse arquivo seguro, você precisará dele mais adiante.

Console

  1. No Console do Cloud, acesse a página IAM e administrador > Contas de serviço do projeto:

    ACESSAR A PÁGINA "CONTAS DE SERVIÇO"

  2. Clique em Criar conta de serviço e insira os detalhes da conta de serviço:

    1. Forneça um nome de conta de serviço, como Income Prediction API.
    2. Forneça um ID da conta de serviço, como income-prediction-api.
    3. Clique em Criar.
  3. Na página Conceda acesso para a conta de serviço ao projeto (opcional), deixe a lista suspensa Papel em branco e clique em Continuar.

  4. Na página Conceda aos usuários acesso a essa conta de serviço (opcional), role para baixo e clique em Criar chave:

    1. Selecione o tipo de chave como JSON, que é o padrão.
    2. Clique em Criar. Seu navegador iniciará o download do arquivo da chave privada. Mantenha esse arquivo seguro, já que você precisará dele mais tarde.
    3. Clique em Concluído.

Como implantar o modelo de predição de renda no AI Platform

Neste tutorial, usamos uma amostra de código existente para treinar um modelo de predição de renda com dados de censo. Para facilitar a tarefa, incluímos um modelo treinado no repositório de códigos deste tutorial no GitHub.

Conclua as etapas a seguir para implantar o modelo de predição de renda pré-treinado no AI Platform:

  1. Abra o Cloud Shell:

    ACESSAR o Cloud Shell

  2. No Cloud Shell, defina as variáveis do ambiente. Elas serão usadas em comandos posteriormente:

    GCS_MODEL_BUCKET=${GOOGLE_CLOUD_PROJECT}-ml-models
    MODEL_NAME=census
    MODEL_VERSION=v1
    MODEL_REGION=us-central1
    
  3. Clone os arquivos deste tutorial do GitHub:

    cd ${HOME}
    
    git clone https://github.com/GoogleCloudPlatform/cloudml-apigee-serving.git
    
  4. Crie um bucket de armazenamento regional do Cloud Storage para armazenar o modelo de predição:

    gsutil mb -c regional -l ${MODEL_REGION} \
        -p ${GOOGLE_CLOUD_PROJECT} gs://${GCS_MODEL_BUCKET}
    
  5. Extraia e copie o modelo no Cloud Storage:

    cd ${HOME}/cloudml-apigee-serving/model
    
    tar zxvf census.tar.gz
    
    gsutil -m cp -rv census gs://${GCS_MODEL_BUCKET}
    
  6. Crie o modelo de predição no AI Platform:

    gcloud ml-engine models create ${MODEL_NAME} \
         --regions ${MODEL_REGION}
    
  7. Crie uma nova versão do modelo de predição:

    gcloud ml-engine versions create ${MODEL_VERSION} \
        --model ${MODEL_NAME} \
        --origin gs://${GCS_MODEL_BUCKET}/census \
        --runtime-version 1.6
    
  8. Consiga informações sobre a nova versão:

    gcloud ml-engine versions describe ${MODEL_VERSION} \
        --model ${MODEL_NAME}
    

    A saída se parecerá com o seguinte:

    deploymentUri: your_bucket_path
    framework: TENSORFLOW
    isDefault: true
    lastUseTime: '2018-05-07T04:41:22Z'
    name: projects/your_project/models/census/versions/v1
    pythonVersion: '2.7'
    runtimeVersion: '1.6'
    state: READY
    
  9. Antes de continuar, veja se você consegue executar predições:

    gcloud ml-engine predict \
        --model ${MODEL_NAME} \
        --version ${MODEL_VERSION} \
        --json-instances ${HOME}/cmle-op-apigee-tutorial/model/test.json
    

    A saída será semelhante à mostrada abaixo. Esse resultado verifica se o modelo hospedado foi implantado corretamente no AI Platform e pode ser chamado por meio da predição on-line do AI Platform.

    CLASS_IDS  CLASSES  LOGISTIC               LOGITS                PROBABILITIES
    [0]        [u'0']   [0.23072466254234314]  [-1.204223871231079]  [0.7692753076553345, 0.23072466254234314]
    

Como implantar o proxy de API na Apigee

Um proxy de API oferece uma maneira de os clientes chamarem o modelo hospedado por uma API externa. O proxy de API executa essa tarefa enviando solicitações de cliente de uma interface de API externa hospedada pela Apigee para a API AI Platform predict do modelo hospedado. A interface implementa um padrão de fachada de API que protege os usuários contra alterações no endpoint de destino à medida que novos modelos e versões deles são implantados. Veja mais informações em Proxies de API.

Em uma configuração de proxy de API, você usa fluxos para configurar as etapas de processamento executadas na solicitação e na resposta de sua API. As etapas de processamento podem incluir atividades como geração e assinatura de tokens da Web JSON (JWT, na sigla em inglês), inclusão de cabeçalhos de solicitação e resposta ou uso de recursos específicos da Apigee. A Apigee fornece várias políticas de API integradas para executar essas atividades. Você pode incluir essas políticas nos fluxos de sua API.

A Apigee oferece várias maneiras para implantar proxies de API. Entre elas, a interface de gerenciamento Web (login obrigatório), as APIs de gerenciamento e as ferramentas de linha de comando.

Para este tutorial, use apigeetool para criar os recursos necessários da Apigee e implantar o proxy da API.

  1. Abra o Cloud Shell:

    ACESSAR o Cloud Shell

  2. No Cloud Shell, configure as variáveis de ambiente. Você precisará delas mais tarde. Substitua [YOUR_APIGEE_USER_EMAIL], [YOUR_APIGEE_ORGANIZATION], [YOUR_APIGEE_ENVIRONMENT] e [YOUR_APIGEE_USER_PASSWORD] pelos seus valores.

    • Sua conta do Apigee recebe automaticamente o papel Administrador da organização e tem acesso de superusuário a todos os recursos contidos na organização do Apigee. Saiba mais sobre a função de diferentes papéis do Apigee.
    • Sua organização do Apigee é criada automaticamente. Encontre o nome de sua organização na interface de gerenciamento Web do Apigee, no canto superior esquerdo da página em que o nome de sua conta é exibido.
    • Dois ambientes do Apigee, chamados test e prod, foram criados automaticamente para você. Use qualquer um deles nos próximos passos.

    1. Exporte as variáveis de ambiente exigidas por apigeetool:

      export APIGEE_USERNAME=[YOUR_APIGEE_USER_EMAIL]
      export APIGEE_ORGANIZATION=[YOUR_APIGEE_ORGANIZATION]
      
    2. Também é possível exportar uma variável de ambiente para sua senha do Apigee:

      export APIGEE_PASSWORD=[YOUR_APIGEE_USER_PASSWORD]
      
    3. Configure outras variáveis de ambiente necessárias para trabalhar com seu ambiente do Apigee:

      APIGEE_ENVIRONMENT=[YOUR_APIGEE_ENVIRONMENT]
      
    4. Mantenha o nome do cache do Apigee como "google":

      APIGEE_CACHE=google
    5. Configure variáveis de ambiente para o nome e a versão do seu modelo do AI Platform. Essas variáveis precisam ser os mesmos valores usados anteriormente para a implantação da versão do modelo:

      MODEL_NAME=census
      MODEL_VERSION=v1
      
    6. Configure uma variável de ambiente para a conta de serviço usada pelo Apigee para chamar a previsão on-line do AI Platform:

      SERVICE_ACCOUNT=income-prediction-api@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com
      
  3. Instale o apigeetool, que você usa para criar recursos da Apigee e implantar o proxy da API:

    npm install -g apigeetool
    
    alias apigeetool=$(npm config get prefix)/bin/apigeetool
    
  4. Extraia a chave privada de sua conta de serviço do arquivo de credenciais JSON salvo anteriormente:

    PRIVATE_KEY=`sed -rne 's/^.*\"private_key\": \"(.*)\",$/\1/p' <  ${HOME}/key.json`
    
  5. Crie um mapa de chave-valor (KVM) criptografado para armazenar com segurança o nome e a chave privada da conta de serviço na Apigee:

    apigeetool createkvmmap \
        -e ${APIGEE_ENVIRONMENT} \
        --encrypted \
        --mapName "secrets"
    
  6. Inclua o nome da conta de serviço no KVM criptografado:

    apigeetool addEntryToKVM \
        -e ${APIGEE_ENVIRONMENT} \
        --mapName "secrets" \
        --entryName "service-account" \
        --entryValue "${SERVICE_ACCOUNT}"
    
  7. Inclua a chave privada no KVM criptografado:

    apigeetool addEntryToKVM \
        -e ${APIGEE_ENVIRONMENT} \
        --mapName "secrets" \
        --entryName "private-key" \
        --entryValue "`echo -e ${PRIVATE_KEY}`"
    
  8. Atualize o endpoint do proxy da API no seu modelo implantado no AI Platform. O proxy da API encaminha solicitações para o método projects.predict do modelo hospedado na previsão on-line do AI Platform.

    sed -i \
        -e "s/\[project\]/${GOOGLE_CLOUD_PROJECT}/" \
        -e "s/\[model-name\]/${MODEL_NAME}/" \
        -e "s/\[model-version\]/${MODEL_VERSION}/" \
        ${HOME}/cmle-op-apigee-tutorial/apiproxy/targets/default.xml
    
  9. Crie um cache do Apigee para armazenamento temporário dos tokens de acesso do OAuth2 retornados do Google Authorization Server:

    apigeetool createcache \
        -e ${APIGEE_ENVIRONMENT} \
        -z ${APIGEE_CACHE}
    
  10. Conceda permissões do gerenciamento de identidade e acesso (IAM) para autorizar que a conta de serviço solicite previsões em seu modelo. Para conceder essas permissões, adicione a vinculação da política do IAM ao modelo census da seguinte maneira:

    gcloud ml-engine models add-iam-policy-binding \
        ${MODEL_NAME} \
        --member=serviceAccount:${SERVICE_ACCOUNT} \
        --role=roles/ml.modelUser
    
  11. Implante o proxy de API:

    apigeetool deployproxy  \
        -e ${APIGEE_ENVIRONMENT} \
        -n income_prediction -d ${HOME}/cmle-op-apigee-tutorial
    

Como criar produtos de API para distribuir suas APIs

Use um produto de API do Apigee para configurar níveis específicos de acesso e funcionalidade expostos a desenvolvedores. Por exemplo, é possível criar dois produtos de API para refletir os níveis de serviço "Trial" e "Premium" nos seus modelos hospedados no AI Platform, em que cada nível é diferenciado por cotas, funcionalidade acessível e outros recursos.

Nesta seção, você cria dois produtos de API: Income Prediction Trial e Income Prediction Premium. Você configura esses dois produtos para usar o proxy de API que implantou na etapa anterior, mas impõe diferentes políticas de uso, conforme explicado aqui:

  • O produto de API Income Prediction Trial impõe uma baixa cota de uso diário, mas permite que os desenvolvedores consigam chaves de API por meio de um processo automatizado. Essa política pode refletir um nível de "avaliação gratuita", em que você fornece um acesso simples à sua API e limites de uso relativamente baixos.

  • O produto de API Income Prediction Premium oferece uma cota de uso diário mais elevada, mas exige que os desenvolvedores passem por um processo de aprovação manual. Essa política pode refletir um nível pago para sua API que fornece acesso e limites de uso elevados.

Para criar os produtos de API, siga estas etapas:

  1. Crie o produto de API Income Prediction Trial:

    apigeetool createProduct \
        --approvalType "auto" \
        --environments ${APIGEE_ENVIRONMENT} \
        --proxies income_prediction \
        --productName "income_prediction_trial" \
        --productDesc "Free trial API for income prediction." \
        --quota 10 \
        --quotaInterval 1 \
        --quotaTimeUnit "day"
    
  2. Crie o produto de API Income Prediction Premium:

    apigeetool createProduct \
        --approvalType "manual" \
        --environments ${APIGEE_ENVIRONMENT} \
        --proxies income_prediction \
        --productName "income_prediction_premium" \
        --productDesc "Premium API for income prediction." \
        --quota 10000 \
        --quotaInterval 1 \
        --quotaTimeUnit "day"
    

Como criar perfis de desenvolvedor

Os perfis de desenvolvedor podem ser criados por um administrador da Apigee, ou por indivíduos que usam um fluxo de assinatura de autoatendimento.

  1. Crie um perfil de desenvolvedor para John:

    apigeetool createDeveloper \
        --email john@example.com \
        --firstName John \
        --lastName Citizen \
        --userName john@example.com
    
  2. Crie um segundo perfil de desenvolvedor para Sally:

    apigeetool createDeveloper \
        --email sally@example.com \
        --firstName Sally \
        --lastName Resident \
        --userName sally@example.com
    

Como registrar aplicativos de desenvolvedor

Nesta seção, você registrará manualmente os aplicativos de desenvolvedor para os dois perfis de desenvolvedor.

Ao concluir cada um dos comandos a seguir corretamente, você verá uma resposta JSON exibida no terminal. Para cada comando, anote o valor da propriedade consumerKey, que é a chave de API gerada para o aplicativo de desenvolvedor.

  1. Registre o aplicativo de desenvolvedor FooApp e associe-o a John, para usar com o produto de API Income Prediction Trial. Esse comando usa jq para extrair o valor da propriedade consumerKey da resposta. Anote esse valor.

    FOOAPP_API_KEY="$(apigeetool createApp \
        --apiProducts "income_prediction_trial" \
        --name "FooApp" \
        --email john@example.com \
        | jq -r '.credentials[0].consumerKey')"
    
  2. Registre o aplicativo de desenvolvedor BarApp e associe-o a Sally para usar com o produto de API Income Prediction Premium. Anote o valor consumerKey na saída.

    BARAPP_API_KEY="$(apigeetool createApp \
        --apiProducts "income_prediction_premium" \
        --name "BarApp" \
        --email sally@example.com \
        | jq -r '.credentials[0].consumerKey')"
    

Como testar o proxy de API

Para testar o proxy de API, agora é possível usar a chave de API para chamar a API Income Prediction.

  1. Teste a chave de API (o valor da propriedade consumerKey) para o aplicativo FooApp que está registrado para o desenvolvedor John.

    curl -s -X POST \
        -H "Content-Type: application/json" \
        -H "X-APIKEY: ${FOOAPP_API_KEY}" \
        -d '{
            "instances": [{
                "age": 25,
                "workclass": "Private",
                "education": "Some-college",
                "education_num": 1,
                "marital_status": "Never-married",
                "occupation": "Other-service",
                "relationship": "Other-relative",
                "race": "Other",
                "gender": "Female",
                "capital_gain": 0,
                "capital_loss": 0,
                "hours_per_week": 40,
                "native_country": "United-States"}]
        }' \
        https://${APIGEE_ORGANIZATION}-${APIGEE_ENVIRONMENT}.apigee.net/ml/census/v1/predict
    

    Se o teste for bem-sucedido, a resposta será similar a esta:

    {
        "predictions":[
            {
                "probabilities":[
                    0.7692753076553345,
                    0.23072466254234314
                ],
                "class_ids":[
                    0
                ],
                "classes":[
                    "0"
                ],
                "logits":[
                    -1.204223871231079
                ],
                "logistic":[
                    0.23072466254234314
                ]
            }
        ]
    }
    

    Repita a solicitação mais 10 vezes para esgotar a cota:

    for i in `seq 10`; do !! | jq '.' ; done
    

    Quando a cota é excedida, a Apigee retorna um erro:

    {
        "fault":{
            "detail":{
                "errorcode": "policies.ratelimit.QuotaViolation"
            },
            "faultstring": "Rate limit quota violation. Quota limit exceeded. Identifier : \_default"
        }
    }
    

    A solicitação é rejeitada se a chave de API é removida do cabeçalho da solicitação:

    {
        "fault":{
            "faultstring": "Failed to resolve API Key variable request.header.X-APIKEY",
            "detail":{
               "errorcode": "steps.oauth.v2.FailedToResolveAPIKey"
            }
        }
    }
    
  2. Teste a chave de API (o valor da propriedade consumerKey) do aplicativo BarApp, que está registrado ao desenvolvedor Sally.

    curl -s -X POST \
        -H "Content-Type: application/json" \
        -H "X-APIKEY: ${BARAPP_API_KEY}" \
        -d '{
            "instances": [{
                "age": 25,
                "workclass": "Private",
                "education": "Some-college",
                "education_num": 1,
                "marital_status": "Never-married",
                "occupation": "Other-service",
                "relationship": "Other-relative",
                "race": "Other",
                "gender": "Female",
                "capital_gain": 0,
                "capital_loss": 0,
                "hours_per_week": 40,
                "native_country": "United-States"}]
        }' \
        https://${APIGEE_ORGANIZATION}-${APIGEE_ENVIRONMENT}.apigee.net/ml/census/v1/predict | jq '.'
    

    A resposta é similar à mostrada a seguir, porque o produto de API referente à chave de API ainda não foi aprovado:

    {
        "fault": {
            "faultstring": "Invalid ApiKey for given resource",
            "detail": {
                "errorcode": "oauth.v2.InvalidApiKeyForGivenResource"
            }
        }
    }
    

Como aprovar e revogar produtos de API

Na etapa anterior, o proxy de API retornou um erro quando a chave de API referente ao aplicativo BarApp foi usada, porque o produto de API não foi aprovado para uso com a chave de API.

Para aprovar o produto de API para uso com a chave de API BarApp, você pode usar a API Apigee Management. Como alternativa, use a interface da Web da Apigee para aprovar o produto de API. Saiba mais sobre como aprovar ou revogar manualmente as chaves de API usando a interface da Web.

Conclua as etapas a seguir no Cloud Shell para aprovar o produto de API usando a API de gerenciamento da Apigee.

  1. Configure as variáveis de ambiente, que serão necessárias em comandos posteriores:

    DEVELOPER_EMAIL=sally@example.com
    APP_NAME=BarApp
    API_PRODUCT=income_prediction_premium
    
  2. Chame a API Apigee Management para aprovar o produto de API para uso com a chave de API:

    curl -s -X POST \
        -u "${APIGEE_USERNAME}" \
        --header "Content-Type: application/octet-stream" \
        "https://api.enterprise.apigee.com/v1/organizations/${APIGEE_ORGANIZATION}/developers/${DEVELOPER_EMAIL}/apps/${APP_NAME}/keys/${BARAPP_API_KEY}/apiproducts/${API_PRODUCT}?action=approve"
    
  3. Repita a solicitação de API usando a chave de API:

    curl -s -X POST \
        -H "Content-Type: application/json" \
        -H "X-APIKEY: ${BARAPP_API_KEY}" \
        -d '{
            "instances": [{
                "age": 25,
                "workclass": "Private",
                "education": "Some-college",
                "education_num": 1,
                "marital_status": "Never-married",
                "occupation": "Other-service",
                "relationship": "Other-relative",
                "race": "Other",
                "gender": "Female",
                "capital_gain": 0,
                "capital_loss": 0,
                "hours_per_week": 40,
                "native_country": "United-States"}]
        }' \
        https://${APIGEE_ORGANIZATION}-${APIGEE_ENVIRONMENT}.apigee.net/ml/census/v1/predict | jq '.'
    

    A saída é parecida com o exemplo mostrado a seguir, porque o produto de API referente à chave de API está aprovado:

    {
        "predictions":[
            {
                "probabilities":[
                    0.7692753076553345,
                    0.23072466254234314
                ],
                "class_ids":[
                    0
                ],
                "classes":[
                    "0"
                ],
                "logits":[
                    -1.204223871231079
                ],
                "logistic":[
                    0.23072466254234314
                ]
            }
        ]
    }
    

Como ativar o registro de autoatendimento usando o portal do desenvolvedor

Neste tutorial, você usou uma conta administrativa do Apigee para criar perfis de desenvolvedores, aplicativos e chaves de API.

Talvez você queira ativar o registro de autoatendimento para seu produto de API usando o Portal de serviços do desenvolvedor. Esse portal permite que os usuários registrem perfis e aplicativos de desenvolvedores e gerem chaves de API por meio de um fluxo de autoatendimento. Se você ativar um portal de autoatendimento, os usuários individuais podem conseguir acesso à sua API por meio de um fluxo automatizado. Dependendo de suas necessidades, a aprovação da chave de API por meio desse fluxo automatizado pode ocorrer automaticamente ou ainda exigir aprovação manual.

A Apigee fornece uma ferramenta gráfica baseada na Web para a criação de seu portal do desenvolvedor. Saiba mais sobre como criar um portal do desenvolvedor para seus produtos de API.

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

  • Exclua o projeto.
  • Encerre sua conta de avaliação da Apigee.
  • Pare de atender solicitações do proxy da API.

Exclua o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Encerrar sua conta de avaliação da Apigee

Sua conta de avaliação da Apigee será encerrada automaticamente quando o período de avaliação expirar. Não é necessário tomar nenhuma medida específica para excluir sua conta de avaliação.

Parar de atender solicitações do proxy da API

A fim de parar de atender solicitações de proxy de API, remova a implantação ou exclua o proxy de API. Além disso, para evitar novos registros, exclua todos os Portais do desenvolvedor.

  1. No Cloud Shell, remova a implantação do proxy da API usando apigeetool:

    apigeetool undeploy \
        -u ${APIGEE_USERNAME} \
        -o ${APIGEE_ORGANIZATION} \
        -n income_prediction
        -e ${APIGEE_ENVIRONMENT} \
        -r 1 \
        -n income_prediction
    

    A saída se parecerá com o seguinte:

    "income_prediction" Revision 1
      undeployed
      environment = test
      base path = /
    

A seguir