O que é CaaS – Contêineres como um serviço?

Neste artigo, falaremos sobre contêineres como serviço (CaaS). Um dos modelos de nuvem mais novos, mas poderosos. Você aprenderá sobre suas principais funcionalidades, prós e contras, como ele se compara a outros modelos de nuvem e como implantar um aplicativo simples usando contêineres.

Principais conclusões

• O CaaS facilita o desenvolvimento e a implementação contínuos com funcionalidades incorporadas.
• O CaaS oferece alta escalabilidade e portabilidade, reduzindo o aprisionamento ao fornecedor.
• As limitações do CaaS incluem possíveis riscos de segurança e uma curva de aprendizado acentuada.

O que são contêineres como serviço?

A definição de CaaS é Containers as a Service, um modelo de computação em nuvem que permite aos desenvolvedores fazer upload, criar, dimensionar e gerenciar contêineres.

Os contêineres de DevOps são pacotes executáveis leves e autônomos que incluem tudo o que é necessário para executar um aplicativo. Isso consiste em tempo de execução, código, bibliotecas, arquivos de configuração e muito mais. Os contêineres são altamente portáteis, pequenos em tamanho e eficientes.

Ao utilizar o CaaS, os desenvolvedores e as equipes de operações de TI não precisam se preocupar com a infraestrutura subjacente. Em vez disso, elas podem pensar em um nível muito mais elevado.

Eles só precisam codificar o aplicativo, dockerizá-lo e enviá-lo para a nuvem. O provedor de nuvem cuidará de todo o resto, como dimensionamento, balanceamento de carga e monitoramento!

Além disso, o CaaS é excelente, pois promove o desenvolvimento ágil, oferece suporte à arquitetura de microsserviços e é extremamente útil para a criação rápida de aplicativos altamente dimensionáveis.

Quais são as principais funcionalidades do Containers as a Service?

Não há nenhuma especificação oficial que defina os recursos que um CaaS deve incluir. Eles variam de fornecedor para fornecedor. No entanto, as funcionalidades mais básicas dos contêineres como serviço são:

• Tempo de execução do contêiner (responsável por executar seus aplicativos em contêineres)
• Registro de contêineres (permite armazenar e distribuir imagens Docker já criadas)
• Dimensionamento automático (aumenta ou diminui o número de contêineres com base no tráfego)
• Sistema CI/CD integrado (extrai seu código de um sistema VCS, como o GitHub ou o GitLab)
• Balanceamento de carga (divide o tráfego entre vários contêineres para melhorar o desempenho)
• Monitoramento e registro (fornece recursos avançados de monitoramento de contêineres)

Quais são as vantagens dos contêineres como serviço?

Desenvolvimento e implantação mais rápidos

Ao usar o CaaS, você pode acelerar significativamente o processo de desenvolvimento e implantação de software. Os contêineres facilitam a configuração dos ambientes de desenvolvimento local para os desenvolvedores que estão sendo integrados. Tudo o que eles precisam fazer é executar um ou dois comandos em vez de instalar um monte de dependências ou mexer nas configurações do sistema operacional.

Além disso, uma vez que seu projeto esteja em contêineres, ele pode ser facilmente implantado em qualquer fornecedor de CaaS.

Eficiência de recursos

Os contêineres têm uma natureza favorável aos recursos. Eles foram projetados para utilizar com eficiência os recursos do sistema, como CPU, memória e armazenamento. Com os contêineres, geralmente é possível executar mais aplicativos com menos recursos do sistema. Em comparação com as VMs, os contêineres são mais otimizados em termos de recursos.

Portabilidade

Os aplicativos em contêineres são altamente portáteis, pois não dependem do sistema operacional ou do hardware subjacente. Usando o CaaS, você nunca mais terá o problema de “isso funciona na minha máquina”.

Além disso, os contêineres eliminam o risco de dependência do fornecedor. Se você não estiver satisfeito com seu fornecedor atual, poderá mudar facilmente de um fornecedor para outro sem modificar muito seu código.

Escalabilidade

Os contêineres combinados com software de orquestração, como o Kubernetes, são altamente dimensionáveis. A maioria dos fornecedores de CaaS tem recursos integrados de dimensionamento automático, balanceamento de carga e muito mais. Isso permite que eles acomodem qualquer tráfego e reduzam rapidamente a escala quando o pico de tráfego termina.

Operação simplificada

O CaaS preenche a lacuna entre o ambiente de desenvolvimento e o de produção. Além disso, ele simplifica o processo de DevOps oferecendo um sistema CI/CD integrado, que se integra ao seu sistema VCS.

O melhor de tudo é que o CaaS permitirá que você corte custos significativos, pois não precisará de administradores de sistemas ou engenheiros de DevOps.

Quais são as limitações dos contêineres como serviço?

Problemas de segurança

Os contêineres oferecem menos isolamento e segurança do que as VMs, pois compartilham o mesmo kernel do sistema. Isso pode ser um risco potencial à segurança. Se você estiver executando os processos do contêiner do Docker como root, um hacker poderá sair do contêiner e assumir o controle do sistema host.

Falta de controle

As plataformas de CaaS normalmente oferecem um nível menor de controle em comparação com outros modelos de nuvem. Os clientes não podem fazer o ajuste fino das máquinas em que seus contêineres são executados ou configurar como seus aplicativos devem ser dimensionados.

Curva de aprendizado

O modelo de contêineres como serviço é mais desafiador do que o PaaS ou o BaaS. Ele exige muito conhecimento técnico sobre programação, tecnologia de conteinerização, Docker etc. Ele tem uma curva de aprendizado mais acentuada, mas dominá-lo pode ajudá-lo a economizar muito tempo e dinheiro.

Persistência de dados

Os contêineres são projetados para serem stateless. Eles não devem ser usados para armazenar arquivos, bancos de dados ou qualquer outra coisa que exija persistência de dados. Usando o CaaS, você terá de utilizar um serviço de terceiros para hospedar arquivos, como o AWS S3, o Google Cloud Storage, etc. Quanto ao banco de dados, você pode optar por uma solução de banco de dados gerenciado.

Qual é a função do Docker e do Kubernetes em uma plataforma de CaaS?

O Docker e o Kubernetes desempenham um papel crucial na maioria das plataformas de CaaS.

O Docker é uma plataforma gratuita e de código aberto para criar, implantar, executar e gerenciar contêineres. Foi lançada em 2013 e se tornou o padrão de fato para empacotar software em contêineres.

O Kubernetes (às vezes também chamado de K8s) é um software de orquestração. Ele funciona em um nível mais alto do que o Docker. O objetivo do Kubernetes é garantir que os clusters de contêineres funcionem bem juntos. Ele cuida do dimensionamento, do balanceamento de carga, da substituição de contêineres quebrados, etc.

Como o Containers as a Service se compara a outros modelos?

Nesta seção, compararemos o CaaS com outros serviços de computação em nuvem, incluindo IaaS, PaaS e BaaS. Todos eles têm seus prós e contras que devem ser considerados ao implantar seu projeto.

Com base nas camadas de abstração, a CaaS fica em algum lugar entre a IaaS e a PaaS (conforme ilustrado na imagem abaixo).

CaaS vs IaaS

Infraestrutura como serviço (IaaS) é um modelo flexível de computação em nuvem no qual um provedor de nuvem oferece a infraestrutura básica em um ambiente virtualizado. Isso inclui servidores, armazenamento, sistemas operacionais e redes. A IaaS é a opção menos abstraída e oferece aos clientes controle total sobre sua infraestrutura.

A CaaS é menos flexível e oferece um nível de controle menor do que a IaaS. Mas, por outro lado, é muito mais fácil de gerenciar e permite maior escalabilidade e portabilidade. Como regra geral, use a IaaS se precisar de controle de alto nível e a CaaS se precisar de uma maneira rápida de implantar aplicativos escaláveis em contêineres.

CaaS vs PaaS

A PaaS (Platform as a Service) é um serviço de computação em nuvem que fornece aos desenvolvedores as ferramentas para criar e implementar seus aplicativos. A PaaS permite que os usuários se concentrem em seu aplicativo em vez de se preocuparem com a infraestrutura subjacente. A maioria dos provedores de PaaS permite que você coloque seu aplicativo em execução com um ou dois cliques!

A CaaS é mais flexível e dimensionável em comparação com a PaaS. A CaaS permite que você implemente praticamente qualquer coisa, enquanto os provedores de PaaS geralmente se limitam a algumas linguagens de programação. Em termos de ferramentas e recursos de desenvolvimento de software, a PaaS é mais avançada. A PaaS é mais adequada para aplicativos monolíticos, enquanto a CaaS é superior na arquitetura de microsserviços.

Para saber mais sobre a plataforma como serviço, confira o artigo O que é Paas?

CaaS vs BaaS

Backend as a Service (BaaS) é um modelo de computação em nuvem que abstrai completamente o lado de backend de um projeto. Ele vem com um banco de dados, armazenamento de arquivos, gerenciamento de usuários, APIs, SDKs, notificações push e autenticação, para citar alguns. O BaaS permite que você se concentre no frontend e na lógica comercial, em vez de perder tempo e dinheiro com tarefas repetitivas de programação.

O CaaS pode ser usado para implantar back-ends e front-ends, enquanto o BaaS é usado principalmente para implantar back-ends. A BaaS é extremamente fácil de usar e, às vezes, não requer nenhum código. O CaaS, por outro lado, requer uma quantidade razoável de conhecimento técnico de programação, dockerização e DevOps.

Para saber mais sobre Backend as a Service, confira O que é BaaS?

Quais são os melhores provedores de contêineres como serviço?

Back4app Containers

O Back4app Containers é um serviço de nuvem avançado que oferece uma plataforma CaaS para implantação e dimensionamento de aplicativos em contêineres distribuídos globalmente.

Ela permite que os desenvolvedores se concentrem em seu software e no processo de dockerização sem se preocupar com DevOps. A plataforma tem um sistema de CI/CD integrado, integração com o GitHub e suporta implementações sem tempo de inatividade.

O melhor de tudo é que ele oferece um plano gratuito e permite que você coloque seu aplicativo em funcionamento em questão de minutos!

Amazon Elastic Container Service

O Amazon Elastic Container Service (ECS) é um serviço de orquestração de contêineres totalmente gerenciado que simplifica o gerenciamento e a implantação de software em contêineres. Tudo o que você precisa fazer é descrever seu aplicativo e os recursos necessários, e o AWS cuidará de todo o resto.

Não há cobrança exclusiva para o ECS, pois ele utiliza outros serviços da AWS em segundo plano. Para usar o ECS de forma eficaz, você deve estar familiarizado com o ecossistema da AWS. A AWS também oferece um nível gratuito para novos clientes.

Google Cloud Kubernetes

O Google Cloud Kubernetes (GKE) é a plataforma de orquestração baseada no Kubernetes do Google. Ela permite que você coloque seus contêineres no piloto automático, eliminando a necessidade de gerenciar nós. Ele vem com aplicativos e modelos pré-construídos do Kubernetes, recursos de dimensionamento automático, gerenciamento de vários clusters e muito mais!

O GKE é excepcionalmente eficiente e flexível, mas exige muita configuração inicial. Isso faz com que ele não seja adequado para iniciantes. Como as outras duas opções, o Google também oferece créditos gratuitos para novos usuários.

Como hospedar um aplicativo simples usando contêineres?

Nesta seção, veremos como criar, dockerizar e implantar um aplicativo Web Python simples. Este guia foi criado especificamente para o Back4app Containers, mas etapas semelhantes podem ser aplicadas a qualquer outro provedor de CaaS.

Objetivos

1. Codifique o aplicativo.
2. Dockerize o aplicativo e teste-o.
3. Envie o código-fonte para o GitHub.
4. Implante o aplicativo no CaaS.

Aplicativo de código

Para demonstrar o processo de implantação, criaremos uma API RESTful simples usando o FastAPI, uma estrutura Python moderna e de alto desempenho para criar APIs prontas para produção.

Configuração do projeto

Comece criando uma pasta dedicada para o projeto e um ambiente virtual:

$ mkdir fastapi-example && cd fastapi-example
$ python3.9 -m venv env && source env/bin/activate

Em seguida, instale o FastAPI com todas as suas dependências:

$ pip install "fastapi[all]"

O uso do especificador extra instala algumas dependências opcionais, como o servidor Uvicorn, o mecanismo de modelos Jinja2 e assim por diante. Se você quiser o mínimo necessário, não inclua o extra.

Crie um arquivo main.py com o seguinte conteúdo:

# main.py

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Back4app Containers rocks!"}

Esse é o aplicativo FastAPI mais básico que você pode escrever. Tivemos que importar a FastAPI, inicializá-la e registrar o endpoint raiz. Visitar / deve retornar a mensagem Back4app Containers rocks!

Executar e testar

Para executar o aplicativo Web, você pode usar o servidor ASGI integrado do Uvicorn:

$ uvicorn main:app --reload

INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [9528] using WatchFiles
INFO:     Started server process [26308]
INFO:     Waiting for application startup.
INFO:     Application startup complete.  

Adicionamos o sinalizador --reload porque queremos que o servidor seja recarregado se fizermos alguma alteração no código-fonte.

Use o cURL para enviar uma solicitação GET para a raiz da API:

$ curl http://localhost:8000/

{
    "message": "Back4app Containers rocks!"
}

requisitos.txt

Outra coisa que precisamos fazer é congelar todos os requisitos em um arquivo requirements.txt. Isso permite que outras pessoas instalem rapidamente todas as dependências necessárias para o nosso projeto.

$ pip freeze > requirements.txt

fastapi==0.97.0
pydantic==1.10.9
python-dotenv==1.0.0
...

Usaremos esse arquivo para instalar as dependências do Python no processo de criação de imagens do Docker.

Aplicativo Dockerize

Antes de prosseguir, certifique-se de ter o Docker em seu computador local. A melhor maneira de verificar isso é executar docker --version em seu terminal.

Dockerfile

Para dockerizar nosso projeto, usaremos um Dockerfile. Um Dockerfile é um arquivo de texto que contém todos os comandos que um usuário poderia executar para montar uma imagem.

Crie um Dockerfile na raiz do projeto da seguinte forma:

# Dockerfile

# Use Alpine Linux as the base image
# we're using it since it's tiny in size (~5 MB)
FROM python:3.9.6-alpine

# Set the working directory
WORKDIR /app

# Set environmental variables
ENV PYTHONDONTWRITEBYTECODE 1  # Prevents Python from writing out .pyc files
ENV PYTHONUNBUFFERED 1         # Keeps Python from buffering stdin/stdout

# Copy over the requirements file and install the dependencies
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy over the source code
COPY . .

# Expose the port
EXPOSE 80

# Run the server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

Dê uma olhada nos comentários para descobrir como funcionam as diferentes instruções.

Não se preocupe; você não precisa memorizar todas as instruções. Se tiver dúvidas, você sempre poderá consultar a documentação do Docker. Além disso, os Dockerfiles para a maioria das linguagens e estruturas podem ser encontrados on-line. Você só precisa copiá-los e adaptá-los às suas necessidades.

.dockerignore

Nosso projeto contém arquivos e diretórios que não queremos incluir na imagem do Docker. Para ignorá-los, podemos usar um arquivo .dockerignore.

Crie um arquivo .dockerignore na raiz do projeto:

# .dockerignore

.git/
.idea/
venv/

Sinta-se à vontade para adicionar outros arquivos e diretórios.

Criar, executar e testar

Antes de implementar seu código no CaaS, certifique-se de que seu projeto seja compilado e executado com êxito em sua máquina.

Comece criando a imagem do Docker:

$ docker build -t fastapi-example:1.0 .

Resumo dos argumentos:

1. -t fastapi-example:1.0 marca/nomeia a imagem.
2. . define o contexto de compilação.

Em seguida, verifique se a imagem foi criada com êxito:

$ docker images

REPOSITORY        TAG       ID             CREATED AT      SIZE
fastapi-example   1.0       33feac11707d   4 seconds ago   72.8MB

Depois disso, use a imagem recém-criada para ativar um novo contêiner:

$ docker run -p 80:80 --name fastapi-example -d fastapi-example:1.0

Resumo dos argumentos:

1. -p 80:80 expõe a porta 80.
2. --name fastapi-example nomeia o contêiner.
3. -d executa o contêiner no modo desanexado (sem ocupar o terminal).
4. fastapi-example:1.0 especifica a imagem a ser usada.

Verifique os contêineres em execução:

$ docker ps

ID        IMAGE                 COMMAND                CREATED   PORTS                
e67fdeg   fastapi-example:1.0   "uvicorn main:app.."   9s ago    0.0.0.0:80->80/tcp  

Por fim, envie uma solicitação GET ao índice da API para ver se você recebe a mensagem:

$ curl http://localhost/

{
    "message": "Back4app Containers rocks!"
}

Para parar o contêiner, você pode usar o seguinte comando:

$ docker kill fastapi-example

Enviar para o GitHub

As próximas etapas exigirão que você tenha uma conta no GitHub. Se não tiver uma, vá em frente e registre-se. Além disso, certifique-se de ter o Git instalado e configurado em sua máquina.

Criar repositório

Você será redirecionado para o seu painel ao fazer login na sua conta do GitHub. Use o botão Adicionar no canto superior direito da tela para ver o formulário de criação do repositório.

Em seguida, dê ao seu repositório um nome descritivo e clique no botão “Create repository” (Criar repositório).

O GitHub levará alguns instantes para criar o repositório. Depois que o repositório for criado, você será redirecionado para ele. Observe a “URL do repositório remoto”.

Enviar código-fonte

Em seguida, navegue de volta para seu projeto local.

Antes de fazer o controle de versão do seu código, é aconselhável criar um arquivo .gitignore. Um arquivo .gitignore permite definir quais arquivos e diretórios não devem ser adicionados ao sistema de controle de versão. Esse arquivo funciona da mesma forma que um arquivo .dockerignore.

Crie um arquivo .gitignore na raiz do projeto com o seguinte conteúdo:

# .gitignore

.idea/
venv/
.env
build/

Sinta-se à vontade para modificar o arquivo de acordo com suas necessidades.

Em seguida, abra o terminal e execute o seguinte comando para inicializar o repositório Git local:

$ git init

Em seguida, adicione todos os arquivos ao VCS e crie o commit inicial:

$ git add .
$ git commit -m "my initial commit"

Por fim, adicione a origem remota do GitHub e envie o código-fonte para ela:

$ git remote add origin <remote_url>
$ git push origin master

Certifique-se de substituir pelo URL remoto da etapa anterior.

Isso deve ser feito. Se você verificar a página do repositório do GitHub agora, verá que todos os arquivos foram adicionados com sucesso.

Implantar aplicativo

Para implantar um aplicativo no Back4app Containers, você precisará de uma conta no Back4app. Se ainda não tiver uma, vá em frente e registre-se.

Ao fazer login, você verá a lista de seus aplicativos. Clique no botão “Build new app” (Criar novo aplicativo) para iniciar o processo de criação do aplicativo.

O Back4app permite que você implemente dois tipos de aplicativos: Backend as a Service (BaaS) ou Containers as a Service (CaaS). Como estamos implementando um aplicativo em contêiner, escolha a opção “Containers as a Service”.

Se ainda precisar vincular seu perfil do GitHub e importar o repositório, criamos na etapa anterior. Em seguida, selecione-o.

O Back4app Containers permite que você personalize bastante a implantação. Você pode definir a ramificação da implantação, o diretório raiz, alternar a implantação automática e definir as variáveis ambientais.

Como estamos implantando um aplicativo simples, não precisamos de nenhuma dessas opções. Você só precisa definir o “App Name” e, em seguida, clicar no botão “Create App”.

O Back4app Containers levará alguns instantes para extrair o código-fonte do GitHub, criar a imagem e ativar um novo contêiner. Quando seu aplicativo estiver pronto, o status será alterado para “Ready” (Pronto).

Quando isso acontecer, você poderá clicar no link verde no lado esquerdo da tela para abrir seu aplicativo no navegador. Você também pode notar que o Back4app Containers emitiu um certificado SSL gratuito para seu aplicativo.

Bom trabalho, é isso!

Conclusão

Concluindo, você aprendeu sobre o CaaS, um dos melhores modelos nativos da nuvem para a arquitetura de microsserviços. Agora você conhece seus principais recursos, benefícios, limitações e os melhores fornecedores de CaaS. Além disso, você aprendeu a implantar um aplicativo simples em docker no Back4app Containers.

O código-fonte do projeto está disponível no repositório back4app-containers-fastapi.

Outras etapas

1. Dê uma olhada nas compilações em vários estágios para aprimorar seus Dockerfiles e facilitar a manutenção deles.
2. É uma boa prática de segurança executar os processos do Docker Container com um usuário não raiz.
3. Consulte a documentação do Back4app Containers para saber como implantar outras linguagens de programação e estruturas.

PERGUNTAS FREQUENTES