One place for hosting & domains

      Serviços de Armazenamento de Objetos versus Armazenamento em Blocos


      Introdução

      O armazenamento de dados flexível e escalável é um requisito básico para a maioria dos aplicativos e serviços que estão sendo desenvolvidos com técnicas e ferramentas modernas. Seja armazenando grandes ou pequenas quantidades de imagens, vídeos ou pequenos blocos de texto, os desenvolvedores de aplicativos precisam de uma solução para o armazenamento e a recuperação do conteúdo gerado por usuários, logs, backups e assim por diante.

      Com os deployments complexos atuais, containers, e infraestrutura efêmera, os dias de simplesmente salvar arquivos no disco em um único servidor acabaram. Provedores de nuvem desenvolveram serviços para preencher as necessidades de armazenamento dos deployments de aplicações modernas, e eles se encaixam principalmente em duas categorias: armazenamento de objetos e armazenamento em blocos.

      Vamos dar uma olhada em ambos e discutir as vantagens, desvantagens e casos de uso para cada um.

      O que é o Armazenamento em Blocos

      Os serviços de armazenamento em blocos ou block storage são relativamente simples e familiares. Eles fornecem um dispositivo de armazenamento em blocos tradicional — como um disco rígido — através da rede. Os provedores de nuvem geralmente têm produtos que podem provisionar um dispositivo de armazenamento em blocos de qualquer tamanho e anexá-lo à sua máquina virtual.

      A partir disso, você poderia tratá-lo como um disco normal. Você pode formatá-lo com um sistema de arquivos e armazenar arquivos nele, combinar vários dispositivos em um RAID, ou configurar um banco de dados para gravar diretamente no dispositivo de blocos, evitando completamente a sobrecarga do sistema de arquivos. Além disso, os dispositivos de armazenamento em blocos conectados à rede geralmente têm algumas vantagens exclusivas em relação aos discos rígidos normais:

      • Você pode tirar snapshots ou instantâneos ao vivo de todo o dispositivo para fins de backup
      • Dispositivos de armazenamento em blocos podem ser redimensionados para acomodar as necessidades de crescimento
      • Você pode facilmente desanexar e mover dispositivos de armazenamento em blocos entre as máquinas

      Esta é uma configuração muito flexível que pode ser útil para a maioria dos aplicativos de qualquer tipo. Vamos resumir algumas vantagens e desvantagens da tecnologia.

      Algumas vantagens do armazenamento em blocos são:

      • O Armazenamento em blocos é um paradigma familiar. Pessoas e softwares entendem e suportam arquivos e sistemas de arquivos quase que universalmente
      • Dispositivos de blocos são bem suportados. Toda linguagem de programação pode ler e gravar arquivos facilmente
      • Permissões de sistema de arquivos e controles de acesso são familiares e bem entendidos
      • Os dispositivos de armazenamento em bloco fornecem I/O de baixa latência, sendo então, adequados para uso por bancos de dados.

      As desvantagens do armazenamento em blocos são:

      • O armazenamento em blocos está ligado a um servidor de cada vez
      • Blocos e sistemas de arquivos tem metadados limitados sobre os blobs de informações que eles estão armazenando (data da criação, proprietário, tamanho). Qualquer informação adicional sobre o que você está armazenando tem que ser tratada no nível da aplicação e do banco de dados, o que é uma complexidade adicional para um desenvolvedor se preocupar
      • Você precisa pagar por todo o espaço de armazenamento em blocos que você alocou, mesmo que você não o esteja usando
      • Você só pode acessar o armazenamento em blocos através de um servidor em execução
      • O armazenamento em blocos precisa de mais trabalho e configuração manual se comparado ao armazenamento de objetos (escolha de sistemas de arquivos, permissões, versionamento, backups, etc).

      Devido às suas características de I/O rápida, os serviços de armazenamento em blocos são adequados para armazenar dados em bancos de dados tradicionais. Além disso, muitos aplicativos legados que exigem armazenamento normal do sistema de arquivos precisarão usar um dispositivo de armazenamento em blocos.

      Se o seu provedor de nuvem não oferece um serviço de armazenamento em blocos, você pode executar o seu próprio serviço usando OpenStack Cinder, Ceph, ou o serviço iSCSI integrado disponível em muitos dispositivos NAS.

      O que é o Armazenamento de Objetos

      No mundo moderno da computação em nuvem, o armazenamento de objetos ou object storage é o armazenamento e a recuperação de blobs (grandes objetos binários) não estruturados de dados e metadados utilizando uma API HTTP. Em vez da quebra dos arquivos em blocos para armazená-los em disco usando um sistema de arquivos, lidamos com objetos inteiros armazenados na rede. Esses objetos podem ser um arquivo de imagem, logs, arquivos HTML ou qualquer bloco de bytes auto contido. Eles são não estruturados porque não há um esquema ou formato específico que eles precisem seguir.

      O Armazenamento de Objetos decolou porque simplificou muito a experiência do desenvolvedor. Como a API consiste de solicitações HTTP padrão, bibliotecas são rapidamente desenvolvidas para a maioria das linguagens de programação. O salvamento de um blob de dados tornou-se tão fácil quanto uma solicitação HTTP PUT ao object store. A recuperação de arquivo e metadados é uma solicitação GET normal. Além disso, a maioria dos serviços de armazenamento de objetos também pode servir os arquivos publicamente para seus usuários, eliminando a necessidade de manter um servidor web para hospedar recursos estáticos.

      Além do mais, os serviços de armazenamento de objetos cobram apenas pelo espaço de armazenamento que você usa (alguns também cobram por solicitação HTTP e por largura de banda de transferência). Isso é um benefício para pequenos desenvolvedores, que podem obter armazenamento de classe mundial e hospedagem de recursos a custos que aumentam com o uso.

      Entretanto, o armazenamento de objetos não é a solução ideal para todas as situações. Vamos olhar um resumo dos benefícios e desvantagens.

      Algumas vantagens do armazenamento de objetos são:

      • Uma API HTTP simples, com clientes disponíveis para todos os principais sistemas operacionais e linguagens de programação
      • Uma estrutura de custos na qual que você paga apenas pelo que usa
      • Um serviço interno de publicação de recursos significando um servidor a menos que você precisa gerenciar
      • Alguns provedores armazenamento de objetos oferecem integração com CDN, que armazena seus recursos em cache em todo o mundo para fazer downloads e carregamentos de página mais rápidos para seus usuários
      • O versionamento opcional significa que você pode recuperar versões antigas de objetos para se proteger da sobrescrita acidental de dados
      • Os serviços de armazenamento de objetos podem escalar facilmente de necessidades modestas para casos de uso realmente intensos, sem que o desenvolvedor tenha que lançar mais recursos ou rearquitetar a aplicação para lidar com a carga
      • Usar um serviço de armazenamento de objetos significa que você não precisa manter discos rígidos e matrizes RAID, pois isso é feito pelo provedor de serviços.
      • A capacidade de armazenar trechos de metadados junto com seu blob de dados pode simplificar ainda mais a arquitetura do seu aplicativo

      Algumas desvantagens do armazenamento de objetos são:

      • Você não pode utilizar serviços de armazenamento de objetos para manter um banco de dados tradicional, devido à alta latência desses serviços
      • O armazenamento de objetos não permite que você altere apenas um fragmento de dados, você deve ler e escrever um objeto inteiro de uma só vez. Por exemplo, em um sistema de arquivos, você pode facilmente adicionar uma única linha ao final de um arquivo de log. Em um sistema de armazenamento de objetos, você precisaria recuperar o objeto, adicionar a nova linha e gravar todo o objeto de volta. Isso torna o armazenamento de objetos menos ideal para dados que mudam com muita frequência
      • Sistemas operacionais não podem montar facilmente um armazenamento de objetos como um disco normal. Existem alguns clientes e adaptadores para ajudar nisso, mas em geral, usar e navegar em um armazenamento de objetos não é tão simples quanto folhear diretórios em um navegador de arquivos

      Devido a essas propriedades, o armazenamento de objetos é útil para hospedar recursos estáticos, salvamento de conteúdo criado por usuários tais como imagens e filmes, armazenamento de arquivos de backup, armazenamento de logs, por exemplo.

      Existem algumas soluções de armazenamento de objetos que você pode hospedar, embora você tenha que abrir mão de alguns dos benefícios de uma solução hospedada (como não ter que se preocupar com discos rígidos e problemas de dimensionamento). Você pode experimentar o Minio, um popular servidor de armazenamento de objetos escrito na linguagem Go, o Ceph, ou o OpenStack Swift.

      Conclusão

      A escolha de uma solução de armazenamento pode ser uma decisão complexa para desenvolvedores. Neste artigo discutimos as vantagens e desvantagens tanto dos serviços de armazenamento em blocos quanto dos serviços de armazenamento de objetos. É provável que qualquer aplicativo suficientemente complexo precisará dos dois tipos de armazenamento para atender a todas as suas necessidades.



      Source link

      Como Construir Imagens Docker e Hospedar um Repositório de Imagens Docker com o GitLab


      Introdução

      A containerização está rapidamente se tornando o método de empacotamento e deploy de aplicações mais aceito nos ambientes de nuvem. A padronização que ele fornece, juntamente com sua eficiência de recursos (quando comparado a máquinas virtuais completas) e flexibilidade, o tornam um grande facilitador da moderna mentalidade DevOps. Muitas estratégias interessantes de deployment, orquestração e monitoramento nativas para nuvem tornam-se possíveis quando suas aplicações e microsserviços são totalmente containerizados.

      Os containers Docker são de longe os tipos mais comuns de container atualmente. Embora os repositórios públicos de imagem do Docker como o Docker Hub estejam repletos de imagens de software opensource containerizado que você pode fazer um docker pull hoje, para código privado você precisará pagar um serviço para construir e armazenar suas imagens, ou executar seu próprio software para fazer isso.

      O GitLab Community Edition é um pacote de software auto-hospedado que fornece hospedagem de repositório Git, acompanhamento de projetos, serviços de CI/CD, e um registro de imagem Docker, entre outros recursos. Neste tutorial vamos utilizar o serviço de integração contínua do GitLab para construir imagens Docker a partir de uma aplicação de exemplo em Node.js. Estas imagens serão então testadas e carregadas para o nosso próprio registro privado do Docker.

      Pré-requisitos

      Antes de começarmos, precisamos configurar um servidor GitLab seguro, e um GitLab CI runner para executar tarefas de integração contínua. As seções abaixo fornecerão links e maiores detalhes.

      Um Servidor Gitlab Protegido com SSL

      Para armazenar nosso código fonte, executar tarefas de CI/CD, e hospedar um registro Docker, precisamos de uma instância do GitLab instalada em um servidor Ubuntu 16.04. Atualmente, o GitLab recomenda um servidor com pelo menos 2 núcleos de CPU e 4GB de RAM. Adicionalmente, iremos proteger o servidor com certificados SSL do Let’s Encrypt. Para fazer isto, precisaremos de um nome de domínio apontando para o servidor.

      Você pode completar esses pré-requisitos com os seguintes tutoriais:

      Um GitLab CI Runner

      O tutorial Como configurar pipelines de integração contínua com o GitLab CI no Ubuntu 16.04 fornecerá uma visão geral do serviço de CI ou integração contínua do GitLab e mostrará como configurar um CI runner para processar jobs. Vamos construir isso em cima da aplicação de demonstração e da infraestrutura do runner criados neste tutorial.

      Passo 1 — Configurando um GitLab CI Runner Privilegiado

      No pré-requisito do tutorial de integração contínua com o GitLab, configuramos um GitLab runner utilizando sudo gitlab-runner register e seu processo de configuração interativo. Este runner é capaz de executar builds e testes de software dentro de containers Docker isolados.

      Entretanto, para se construir imagens Docker, nosso runner precisa de acesso total ao próprio serviço do Docker. A maneira recomendada de se configurar isto é utilizar a imagem docker-in-docker oficial do Docker para executar os jobs. Isto requer conceder ao runner um modo de execução privileged ou privilegiado. Portanto, criaremos um segundo runner com este modo ativado.

      Nota: Conceder ao runner o modo privileged basicamente desativa todas as vantagens de segurança da utilização de containers. Infelizmente, os outros métodos de ativar runners compatíveis com o Docker também carregam implicações de segurança semelhantes. Por favor, veja a documentação oficial do GitLab no Docker Build para aprender mais sobre as diferentes opções de runners e qual é a melhor para a sua situação.

      Como existem implicações de segurança para a utilização de runner privilegiado, vamos criar um runner específico do projeto que aceitará somente jobs de Docker em nosso projeto hello_hapi (Os administradores de GitLab sempre podem adicionar manualmente esse runner a outros projetos posteriormente). A partir da página do nosso projeto hello_hapi, clique em Settings na parte inferior do menu à esquerda, em seguida clique em CI/CD no sub-menu:

      Agora, clique no botão Expand ao lado da seção de configurações de Runners:

      Haverá algumas informações sobre como configurar um Specific Runner, incluindo um token de registro. Tome nota desse token. Quando o utilizamos para registrar um novo runner, o runner será bloqueado apenas para este projeto.

      Estando nesta página, clique no botão Disable shared Runners. Queremos ter certeza de que nossos jobs de Docker sempre executarão em nosso runner privilegiado. Se um runner compartilhado não privilegiado estivesse disponível, o GitLab pode optar por utilizá-lo, o que resultaria em erros de build.

      Faça o login no servidor que possui o seu CI runner atual. Se você não tiver uma máquina já configurada com os runners, volte e complete a seção Installing the GitLab CI Runner Service do tutorial de pré-requisitos antes de continuar.

      Agora, execute o seguinte comando para configurar o runner privilegiado específico do projeto:

      • sudo gitlab-runner register -n
      • --url https://gitlab.example.com/
      • --registration-token seu-token
      • --executor docker
      • --description "docker-builder"
      • --docker-image "docker:latest"
      • --docker-privileged

      Output

      Registering runner... succeeded runner=61SR6BwV Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!

      Certifique-se de substituir suas próprias informações. Nós definimos todas as opções do nosso runner na linha de comando em vez de usar os prompts interativos, porque os prompts não nos permitem especificar o modo --docker-privileged.

      Agora o seu runner está configurado, registrado e executando. Para verificar, volte ao seu navegador. Clique no ícone de chave inglesa na barra de menu principal do GitLab, em seguida clique em Runners no menu à esquerda. Seus runners serão listados:

      Agora que temos um runner capaz de criar imagens do Docker, vamos configurar um registro privado do Docker para carregar imagens para ele.

      Passo 2 — Configurando o Registro Docker do GitLab

      Configurar seu próprio registro do Docker permite que você envie e extraia imagens de seu próprio servidor privado, aumentando a segurança e reduzindo as dependências do seu fluxo de trabalho em serviços externos.

      O GitLab irá configurar um registro Docker privado com apenas algumas atualizações de configuração. Primeiro vamos configurar a URL onde o registro irá residir. Depois, iremos (opcionalmente) configurar o registro para usar um serviço de armazenamento de objetos compatível com S3 para armazenar seus dados.

      Faça SSH em seu servidor GitLab, depois abra o arquivo de configuração do GitLab:

      • sudo nano /etc/gitlab/gitlab.rb

      Role para baixo até a seção Container Registry settings. Vamos descomentar a linha registry_external_url e configurá-la para o nosso host GitLab com a porta número 5555:

      /etc/gitlab/gitlab.rb

      
      registry_external_url 'https://gitlab.example.com:5555'
      

      A seguir, adicione as duas linhas seguintes para dizer ao registro onde encontrar nossos certificados Let’s Encrypt:

      /etc/gitlab/gitlab.rb

      
      registry_nginx['ssl_certificate'] = "/etc/letsencrypt/live/gitlab.example.com/fullchain.pem"
      registry_nginx['ssl_certificate_key'] = "/etc/letsencrypt/live/gitlab.example.com/privkey.pem"
      

      Salve e feche o arquivo, depois reconfigure o GitLab:

      • sudo gitlab-ctl reconfigure

      Output

      . . . gitlab Reconfigured!

      Atualize o firewall para pemitir tráfego para a porta do registro:

      Agora mude para outra máquina com o Docker instalado e efetue o login no registro Docker privado. Se você não tiver o Docker no seu computador de desenvolvimento local, você pode usar qualquer servidor configurado para executar seus jobs do GitLab CI, já que ele tem o Docker instalado:

      • docker login gitlab.example.com:5555

      Você será solicitado para inserir o seu nome de usuário e senha. Use suas credenciais do GitLab para efetuar login.

      Output

      Login Succeeded

      Sucesso! O registro está configurado e funcionando. Atualmente, ele armazenará arquivos no sistema de arquivos local do servidor GitLab. Se você quiser usar um serviço de armazenamento de objetos, continue com esta seção. Se não, pule para o Passo 3.

      Para configurar um backend de armazenamento de objetos para o registro, precisamos saber as seguintes informações sobre o nosso serviço de armazenamento de objetos:

      • Access Key

      • Secret Key

      • Region (us-east-1) por exemplo, se estiver usando Amazon S3, ou Region Endpoint se estiver usando um serviço compatível com S3 (https://nyc.digitaloceanspaces.com)

      • Nome do Bucket

      Se você estiver usando o DigitalOcean Spaces, você pode descobrir como configurar um novo Space e obter as informações acima lendo Como Criar um Space e uma Chave de API na DigitalOcean.

      Quando você tiver suas informações sobre o amazenamento de objetos, abra o arquivo de configuração do GitLab:

      • sudo nano /etc/gitlab/gitlab.rb

      Novamente, role até a seção de registro do container. Procure pelo bloco registry['storage'], descomente o bloco e atualize-o para o seguinte, novamente certificando-se de substituir suas próprias informações, quando apropriado:

      /etc/gitlab/gitlab.rb

      
      registry['storage'] = {
        's3' => {
          'accesskey' => 'sua-key',
          'secretkey' => 'seu-secret',
          'bucket' => 'seu-bucket-name',
          'region' => 'nyc3',
          'regionendpoint' => 'https://nyc3.digitaloceanspaces.com'
        }
      }
      

      Se você estiver uando Amazon S3, você precisa apenas da region e não do regionendpoint. Se estiver usando um serviço S3 compatível, como o Spaces, você irá precisar do regionendpoint. Neste caso, region na verdade não configura nada e o valor que você digita não importa, mas ainda precisa estar presente e não em branco.

      Salve e feche o arquivo.

      Nota: Atualmente, há um bug em que o registro será encerrado após trinta segundos se seu bucket de armazenamento de objetos estiver vazio. Para evitar isso, coloque um arquivo no seu bucket antes de executar a próxima etapa. Você poderá removê-lo mais tarde, após o registro ter adicionado seus próprios objetos.

      Se você estiver usando o Spaces da DigitalOcean, você pode arrastar e soltar um arquivo para carregá-lo usando a interface do Painel de Controle.

      Reconfigure o GitLab mais uma vez:

      • sudo gitlab-ctl reconfigure

      Em sua outra máquina Docker, efetue login no registro novamente para ter certeza de que tudo está bem:

      • docker login gitlab.example.com:5555

      Você deve receber uma mensagem de Login Succeeded.

      Agora que temos nosso registro do Docker configurado, vamos atualizar a configuração de CI da nossa aplicação para criar e testar nossa app, e enviar as imagens Docker para o nosso registro privado.

      Passo 3 — Atualizando o gitlab-ci.yaml e Construindo uma Imagem Docker

      Nota: Se você não concluiu o artigo de pré-requisito do GitLab CI você precisará copiar o repositório de exemplo para o seu servidor GitLab. Siga a seção Copying the Example Repository From GitHub para fazer isto.

      Para que possamos fazer o building de nossa app no Docker, precisamos atualizar o arquivo .gitlab-ci.yml. Você pode editar este arquivo diretamente no GitLab clicando na página principal do projeto, e depois no botão Edit. Alternativamente, você poderia clonar o repositório para a sua máquina local, editar o arquivo, e então fazer um git push nele de volta para o GitLab. Isso ficaria assim:

      • git clone git@gitlab.example.com:sammy/hello_hapi.git
      • cd hello_hapi
      • # edit the file w/ your favorite editor
      • git commit -am "updating ci configuration"
      • git push

      Primeiro, exclua tudo no arquivo, depois cole nele a seguinte configuração:

      .gitlab-ci.yml

      
      image: docker:latest
      services:
      - docker:dind
      
      stages:
      - build
      - test
      - release
      
      variables:
        TEST_IMAGE: gitlab.example.com:5555/sammy/hello_hapi:$CI_COMMIT_REF_NAME
        RELEASE_IMAGE: gitlab.example.com:5555/sammy/hello_hapi:latest
      
      before_script:
        - docker login -u gitlab-ci-token -p $CI_JOB_TOKEN gitlab.example.com:5555
      
      build:
        stage: build
        script:
          - docker build --pull -t $TEST_IMAGE .
          - docker push $TEST_IMAGE
      
      test:
        stage: test
        script:
          - docker pull $TEST_IMAGE
          - docker run $TEST_IMAGE npm test
      
      release:
        stage: release
        script:
          - docker pull $TEST_IMAGE
          - docker tag $TEST_IMAGE $RELEASE_IMAGE
          - docker push $RELEASE_IMAGE
        only:
          - master
      

      Certifique-se de atualizar os URLs e nomes de usuários realçados com suas próprias informações e, em seguida, salve com o botão Commit changes no GitLab. Se você está atualizando o arquivo fora do GitLab, confirme as mudanças e faça git push de volta no GitLab.

      Este novo arquivo de configuração diz ao GitLab para usar a imagem mais recente do docker (image: docker:latest) e vinculá-la ao serviço docker-in-docker (docker:dind). Então, ele define os estágios de build, test, e release. O estágio de build cria a imagem do Docker usando o Dockerfile fornecido pelo repositório, em seguida o carrega para o nosso registro de imagens Docker. Se isso for bem sucedido, o estágio test vai baixar a imagem que acabamos de construir e executar o comando npm test dentro dele. Se o estágio test for bem sucedido, o estágio release irá lançar a imagem, irá colocar uma tag como hello_hapi:latest e irá retorná-la ao registro.

      Dependendo do seu fluxo de trabalho, você também pode adicionar mais estágios test, ou mesmo estágios deploy que levam o aplicativo para um ambiente de preparação ou produção.

      A atualização do arquivo de configuração deve ter acionado um novo build. Volte ao projeto hello_hapi no GitLab e clique no indicador de status do CI para o commit:

      Na página resultante, você pode clicar em qualquer um dos estágios para ver seu progresso:

      Eventualmente, todas as etapas devem indicar que eles foram bem sucedidos, mostrando ícones com a marca de verificação em verde. Podemos encontrar as imagens Docker que acabaram de ser construídas clicando no item Registry no menu à esquerda:

      Se você clicar no pequeno ícone "document" ao lado do nome da imagem, ele copiará o comando apropriado docker pull ... para a sua área de transferência. Você pode então baixar e executar sua imagem:

      • docker pull gitlab.example.com:5555/sammy/hello_hapi:latest
      • docker run -it --rm -p 3000:3000 gitlab.example.com:5555/sammy/hello_hapi:latest

      Output

      > hello@1.0.0 start /usr/src/app > node app.js Server running at: http://56fd5df5ddd3:3000

      A imagem foi baixada do registro e iniciada em um container. Mude para o seu navegador e conecte-se ao aplicativo na porta 3000 para testar. Neste caso, estamos executando o container em nossa máquina local, assim podemos acessá-la via localhost na seguinte URL:

      http://localhost:3000/hello/test
      

      Output

      Hello, test!

      Sucesso! Você pode parar o container com CTRL-C. A partir de agora, toda vez que enviarmos um novo código para a ramificação master do nosso repositório, vamos construir e testar automaticamente uma nova imagem hello_hapi: latest.

      Conclusão

      Neste tutorial, configuramos um novo GitLab runner para criar imagens do Docker, criamos um regisro privado do Docker para armazená-las, e atualizamos um app Node.js para ser construído e testado dentro de containers Docker.

      Para aprender mais sobre os vários componentes utilizados nesta configuração, você pode ler a documentação oficial do GitLab CE, GitLab Container Registry, e do Docker.

      Por Brian Boucheron



      Source link

      Como Instalar e Utilizar o TensorFlow no Ubuntu 16.04


      Introdução

      O TensorFlow é um software open-source para machine learning criado pelo Google para treinar redes neurais. As redes neurais do TensorFlow são expressas na forma de grafos de fluxo de dados com estado. Cada nó no gráfico representa a operação realizada por redes neurais em matrizes multidimensionais. Estas matrizes multidimensionais são comumente conhecidas como “tensors” ou “tensores”, daí o nome TensorFlow.

      O TensorFlow é um sistema de software de deep learning ou aprendizagem profunda. O TensorFlow funciona bem para a recuperação de informações, conforme demonstrado pelo Google na forma como eles fazem a classificação em seu sistema de inteligência artificial de machine-learning, RankBrain. O TensorFlow pode realizar reconhecimento de imagem, como mostrado no Inception do Google, bem como reconhecimento da linguagem humana em áudio. Ele também é útil na solução de outros problemas não específicos para machine-learning, como as equações diferenciais parciais.

      A arquitetura do TensorFlow permite a implantação em várias CPUs ou GPUs em um desktop, servidor ou dispositivo móvel. Existem também extensões para integração com CUDA, uma plataforma de computação paralela da Nvidia. Isso dá aos usuários que estão implantando em uma GPU, acesso direto ao conjunto de instruções virtuais e outros elementos da GPU que são necessários para tarefas computacionais paralelas.

      Neste tutorial, você vai instalar a versão “Suporte apenas à CPU” do TensorFlow. Essa instalação é ideal para pessoas que desejam instalar e usar o TensorFlow, mas que não possuem uma placa de vídeo Nvidia ou não precisam executar aplicações de desempenho crítico.

      Você pode instalar o TensorFlow de diversas formas. cada método tem um caso de uso e um ambiente de desenvolvimento diferentes:

      • Python e Virtualenv: Nessa abordagem, você instala o TensorFlow e todos os pacotes necessários para utilizar o TensorFow em um ambiente virtual Python. Isso isola o seu ambiente TensorFlow de outros programas em Python na mesma máquina.
      • pip nativo: Nesse método, você instala o TensorFlow globalmente em seu sistema. Isso é recomendado para pessoas que querem disponibilizar o TensorFlow para todos em um sistema multiusuário. Esse método de instalação não separa o TensorFlow em um ambiente isolado e pode interferir em outras instalações ou bibliotecas do Python.
      • Docker: O Docker é um ambiente de execução de container e isola completamente o seu conteúdo dos pacotes preexistentes em seu sistema. Nesse método, você usa um container Docker que contém o TensorFlow e todas as suas dependências. Esse método é ideal para incorporar o TensorFlow a uma arquitetura de aplicações maior que já esteja usando o Docker. No entanto, o tamanho da imagem do Docker será bem grande.

      Neste tutorial, você vai instalar o TensorFlow em um ambiente virtual Python com o virtualenv. Essa abordagem, isola a instalação do TensorFlow e coloca as coisas em funcionamento rapidamente. Depois de concluir a instalação, você fará a validação executando um pequeno programa do TensorFlow e, em seguida, usando o TensorFlow para executar o reconhecimento de imagem.

      Pré-requisitos

      Antes de começar esse tutorial, você precisará do seguinte:

      Passo 1 — Instalando o TensorFlow

      Nesse passo vamos criar um ambiente virtual e instalar o TensorFlow.

      Primeiro, crie um diretório de projeto chamado tf-demo:

      Navegue até o seu diretório tf-demo recém criado:

      Em seguida crie um novo ambiente virtual chamado tensorflow-dev. Execute o seguinte comando para criar o ambiente:

      • python3 -m venv tensorflow-dev

      Isso cria um novo diretório tensorflow-dev que conterá todos os pacotes que você instalar enquanto esse ambiente estiver ativado. Ele também inclui o pip e uma versão standalone do Python.

      Agora, ative seu ambiente virtual:

      • source tensorflow-dev/bin/activate

      Uma vez ativado, você verá algo semelhante a isso no seu terminal:

      • (tensorflow-dev)username@hostname:~/tf-demo $

      Agora, você pode instalar o TensorFlow em seu ambiente virtual.

      Execute o seguinte comando para instalar e atualizar para a versão mais nova do TensorFlow disponível no PyPi:

      • pip3 install --upgrade tensorflow

      O TensorFlow irá instalar:

      Output

      Collecting tensorflow Downloading tensorflow-1.4.0-cp36-cp36m-macosx_10_11_x86_64.whl (39.3MB) 100% |████████████████████████████████| 39.3MB 35kB/s ... Successfully installed bleach-1.5.0 enum34-1.1.6 html5lib-0.9999999 markdown-2.6.9 numpy-1.13.3 protobuf-3.5.0.post1 setuptools-38.2.3 six-1.11.0 tensorflow-1.4.0 tensorflow-tensorboard-0.4.0rc3 werkzeug-0.12.2 wheel-0.30.0

      Se você quiser desativar seu ambiente virtual a qualquer momento, o comando é:

      Para reativar seu abiente mais tarde, navegue até o diretório do seu projeto e execute source tensorflow-dev/bin/activate.

      Agora que você instalou o TensorFlow, vamos nos certificar de que a instalação dele está funcionando.

      Passo 2 — Validando a Instalação

      Para validar a instalação do TensorFlow, vamos executar um programa simples nele como um usuário não-root. Vamos utilizar o clássico exemplo de iniciante "Hello, world!" como uma forma de validação. Em vez de criar um arquivo Python, criaremos esse programa usando o Console Interativo do Python.

      Para escrever o programa, inicie o seu interpretador Python:

      Você verá o seguinte prompt aparecer em seu terminal:

      >>>
      

      Esse é o prompt para o interpretador Python, e ele indica que está pronto para que você comece a digitar algumas declarações Python.

      Primeiro, digite essa linha para importar o pacote do TensorFlow e torná-lo disponível como a variável local tf. Pressione ENTER depois de digitar a linha de código:

      Em seguida, adicione esta linha de código para definir a mensagem "Hello, world!":

      • hello = tf.constant("Hello, world!")

      Depois, crie uma nova sessão do TensorFlow e a atribua à variável sess:

      Nota: Dependendo do seu ambiente, você poderá ver esta saída:

      Output

      2017-06-18 16:22:45.956946: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations. 2017-06-18 16:22:45.957158: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.2 instructions, but these are available on your machine and could speed up CPU computations. 2017-06-18 16:22:45.957282: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX instructions, but these are available on your machine and could speed up CPU computations. 2017-06-18 16:22:45.957404: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX2 instructions, but these are available on your machine and could speed up CPU computations. 2017-06-18 16:22:45.957527: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use FMA instructions, but these are available on your machine and could speed up CPU computations.

      Isso lhe diz que você tem um instruction set que tem o potencial de ser otimizado para um desempenho melhor com o TensorFlow. Se você vir isso, poderá ignorá-lo com segurança e continuar.

      Por fim, insira essa linha de código para imprimir o resultado da execução da sessão hello do TensorFlow que você construiu em suas linhas de código anteriores:

      Você verá esta saída em seu console:

      Output

      Hello, world!

      Isso indica que tudo está funcionando e que você pode começar a utilizar o TensorFlow para fazer algo mais interessante.

      Saia do console interativo do Python pressionando CTRL+D.

      Agora vamos usar a API de reconhecimento de imagem do TensorFlow para nos familiarizarmos mais com o TensorFlow.

      Passo 3 — Usando o TensorFlow para Reconhecimento de Imagem

      Agora que o TensorFlow está instalado e que você o validou através da execução de um programa simples, vamos dar uma olhada nos recursos de reconhecimento de imagem do TensorFlow.

      Para classificar uma imagem, você precisa treinar um modelo. Depois você precisa escrever algum código para usar o modelo. Para aprender mais sobre esses conceitos dê uma olhada em An Introduction to Machine Learning.

      O TensorFlow fornece um repositório de modelos e exemplos, incluindo código e um modelo treinado para classificar imagens.

      Utilize o Git para clonar o repositório de modelos do TensorFlow a partir do GitHub dentro do seu diretório de projeto:

      • git clone https://github.com/tensorflow/models.git

      Você verá a seguinte saída enquanto o Git baixa o repositório em uma nova pasta chamada models:

      Output

      Cloning into 'models'... remote: Counting objects: 8785, done. remote: Total 8785 (delta 0), reused 0 (delta 0), pack-reused 8785 Receiving objects: 100% (8785/8785), 203.16 MiB | 24.16 MiB/s, done. Resolving deltas: 100% (4942/4942), done. Checking connectivity... done.

      Vá para o diretório models/tutorials/image/imagenet:

      • cd models/tutorials/image/imagenet

      Este diretório contém o arquivo classify_image.py que usa o TensorFlow para reconhecer imagens. Este programa faz o download de um modelo treinado de tensorflow.org em sua primeira execução. O download desse modelo requer que você tenha 200 MB de espaço livre disponível no disco.

      Neste exemplo, vamos classificar uma imagem pré-fabricada de um Panda. Execute este comando para rodar o programa classificador de imagens:

      Você verá uma saída semelhante a esta:

      Output

      giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca (score = 0.89107) indri, indris, Indri indri, Indri brevicaudatus (score = 0.00779) lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens (score = 0.00296) custard apple (score = 0.00147) earthstar (score = 0.00117)

      Você classificou sua primeira imagem usando os recursos de reconhecimento de imagem do TensorFlow.

      Se você quiser usar outra imagem, faça isso adicionando o argumento -- image_file ao seu comando python3 classify_image.py. Para o argumento, você passaria o caminho absoluto do arquivo da imagem.

      Conclusão

      Você instalou o TensorFlow em um ambiente virtual Python e validou o funcionamento do TensorFlow executando alguns exemplos. Agora você possui ferramentas que o possibilitam a exploração de tópicos adicionais, incluindo Convolutional Neural Networks e Word Embeddings.

      O guia do programador do TensorFlow é um ótimo recurso e referência para o desenvolvimento nesse software. Você pode explorar o Kaggle, um ambiente competitivo para aplicação prática de conceitos de machine learning que o colocam contra outros entusiastas de machine learning, ciência de dados e estatística. Eles têm um excelente wiki onde você pode ver e compartilhar soluções, algumas das quais estão na vanguarda das técnicas estatísticas e de machine learning.



      Source link