DevOps

Introdução ao DevOps: Conceitos básicos e princípios

Virgílio Borges

• 11 min read
Introdução ao DevOps: Conceitos básicos e princípios

DevOps é uma cultura de desenvolvimento de software que visa integrar as equipes de desenvolvimento e operações, automatizar os processos de entrega e monitoramento, além de garantir a qualidade e a confiabilidade dos produtos.

Neste artigo, vamos explicar o que é DevOps, quais são os seus benefícios, como implementá-lo na prática e quais são os principais princípios que orientam essa abordagem.


O que é DevOps?

DevOps é uma contração das palavras “desenvolvimento” e “operações”. O termo surgiu em 2009, quando Patrick Debois organizou um evento chamado DevOpsDays para discutir as dificuldades de colaboração entre as equipes de desenvolvimento e operações de software. Desde então, o conceito se popularizou e se tornou uma referência para as empresas que buscam entregar software de forma rápida, eficiente e contínua.

DevOps não é uma metodologia, uma ferramenta ou um cargo. DevOps é uma cultura, uma forma de pensar e agir que envolve pessoas, processos e tecnologias. O objetivo de DevOps é criar um ambiente de trabalho colaborativo, onde as equipes de desenvolvimento e operações trabalham juntas desde o início do projeto até a entrega e o suporte ao cliente. Dessa forma, é possível reduzir os conflitos, os erros, os atrasos e os custos, além de aumentar a satisfação dos usuários.

Um exemplo de DevOps na prática é o caso da Netflix, uma empresa que oferece serviços de streaming de filmes e séries. A Netflix usa DevOps para entregar novas funcionalidades e atualizações para seus milhões de usuários em todo o mundo. Para isso, a Netflix conta com uma equipe integrada de desenvolvedores e engenheiros que trabalham em conjunto para planejar, testar, implantar e monitorar o software. A Netflix também usa ferramentas como Jenkins, Spinnaker e Chaos Monkey para automatizar os processos de integração contínua (CI), entrega contínua (CD) e teste de resiliência do software.

Um código de exemplo de como usar o Jenkins para criar um pipeline de integração contínua (CI) que executa os testes automatizados a cada commit no repositório de código é:

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                sh 'scp target/my-app.jar user@server:/opt/my-app/'
            }
        }
    }
}


Quais são os benefícios de DevOps?

DevOps traz uma série de benefícios para as empresas que adotam essa cultura. Alguns dos principais são:

  • Melhoria da qualidade do software: ao integrar as equipes de desenvolvimento e operações, é possível garantir que o software atenda aos requisitos funcionais e não funcionais, como desempenho, segurança e escalabilidade. Além disso, ao automatizar os testes e a implantação do software, é possível reduzir os erros humanos e aumentar a confiança no produto.
  • Aumento da velocidade de entrega: ao adotar práticas ágeis e contínuas, como integração contínua (CI) e entrega contínua (CD), é possível acelerar o ciclo de vida do software, desde o planejamento até a produção. Isso permite entregar valor aos usuários com mais frequência e responder às mudanças do mercado com mais agilidade.
  • Redução dos custos: ao otimizar os processos de desenvolvimento e operação do software, é possível eliminar desperdícios, retrabalhos e gargalos. Isso resulta em uma maior eficiência e produtividade das equipes, além de uma menor necessidade de recursos materiais e humanos.
  • Aumento da satisfação dos clientes: ao entregar software de qualidade, rápido e confiável, é possível atender às expectativas e às necessidades dos usuários. Além disso, ao monitorar o comportamento e o feedback dos usuários, é possível obter insights para melhorar o produto continuamente.

Um exemplo de aumento da satisfação dos clientes com DevOps é o caso da Amazon, uma empresa que oferece serviços de comércio eletrônico e computação em nuvem. A Amazon usa DevOps para entregar novas funcionalidades e correções para seus milhões de clientes em todo o mundo. Para isso, a Amazon conta com uma equipe integrada de desenvolvedores e operadores que trabalham em conjunto para planejar, testar, implantar e monitorar o software.

A Amazon também usa ferramentas como AWS CodePipeline, AWS CodeDeploy e AWS CloudFormation para automatizar os processos de integração contínua (CI), entrega contínua (CD) e gerenciamento de infraestrutura do software. Com isso, a Amazon consegue entregar novas versões do software a cada 11,6 segundos, em média, e obter um alto nível de satisfação dos clientes.

Um código de exemplo de como usar o AWS CodePipeline para criar um pipeline de entrega contínua (CD) que implanta o software em diferentes ambientes (desenvolvimento, teste, produção etc.) de forma automatizada e controlada é:

Resources:
  MyFirstPipeline:
    Type: AWS::CodePipeline::Pipeline
    Properties:
      RoleArn: arn:aws:iam::123456789012:role/CodePipelineServiceRole
      Stages:
        - Name: Source
          Actions:
            - Name: SourceAction
              ActionTypeId:
                Category: Source
                Owner: ThirdParty
                Provider: GitHub
                Version: 1
              Configuration:
                Owner: my-github-username
                Repo: my-repo
                Branch: main
                OAuthToken: *****
              OutputArtifacts:
                - Name: MyApp
              RunOrder: 1
        - Name: Deploy
          Actions:
            - Name: DeployAction
              ActionTypeId:
                Category: Deploy
                Owner: AWS
                Provider: CodeDeploy
                Version: 1
              Configuration:
                ApplicationName: MyApp
                DeploymentGroupName: MyDeploymentGroup
              InputArtifacts:
                - Name: MyApp
              RunOrder: 1


Como implementar DevOps na prática?

Não existe uma receita única para implementar DevOps na prática. Cada empresa deve adaptar a cultura DevOps à sua realidade, levando em conta o seu contexto, os seus objetivos, os seus desafios e as suas limitações. No entanto, existem alguns passos que podem ajudar nessa jornada:

  • Definir uma visão compartilhada: o primeiro passo é alinhar as expectativas e os objetivos das equipes de desenvolvimento e operações em relação ao projeto. É importante definir uma visão compartilhada do que se quer alcançar com o produto, quais são os critérios de sucesso e como medir os resultados.
  • Estabelecer uma comunicação efetiva: o segundo passo é estabelecer uma comunicação efetiva entre as equipes de desenvolvimento e operações. É essencial que haja transparência, confiança e feedback constante entre as partes envolvidas. Para isso, é recomendável usar ferramentas que facilitem a comunicação, como chats, videoconferências, quadros kanban etc.
  • Automatizar os processos: o terceiro passo é automatizar os processos de desenvolvimento e operação do software. Isso inclui automatizar os testes (unitários, integrados, funcionais etc.), a integração (CI), a entrega (CD), a implantação (CD), o monitoramento (observability) etc. Para isso, é necessário usar ferramentas que suportem essas práticas, como Jenkins, GitLab CI/CD, Docker, Kubernetes etc. Essas ferramentas permitem criar pipelines de software que executam as tarefas de forma automatizada e padronizada, garantindo a qualidade e a consistência do produto.

Um exemplo de automação dos processos com DevOps é o caso da Spotify, uma empresa que oferece serviços de streaming de música e podcasts. A Spotify usa DevOps para entregar novas funcionalidades e correções para seus milhões de usuários em todo o mundo. Para isso, a Spotify conta com uma equipe integrada de desenvolvedores e operadores que trabalham em conjunto para planejar, testar, implantar e monitorar o software.

A Spotify também usa ferramentas como Jenkins, Docker e Kubernetes para automatizar os processos de integração contínua (CI), entrega contínua (CD) e gerenciamento de infraestrutura do software. Com isso, a Spotify consegue entregar cerca de 200 atualizações por dia, em média, e obter um alto nível de qualidade e confiabilidade do produto.

  • Entrega contínua: o quarto passo é entregar o software aos usuários com a maior frequência possível, sem comprometer a qualidade e a segurança. Isso implica em adotar um ciclo de vida do software ágil e iterativo, onde as mudanças são feitas em pequenos incrementos e validadas constantemente. Isso permite entregar valor aos usuários com mais frequência e responder às mudanças do mercado com mais agilidade.

Um exemplo de entrega contínua com DevOps é o caso do Facebook, uma empresa que oferece serviços de rede social e mídia social. O Facebook usa DevOps para entregar novas funcionalidades e correções para seus bilhões de usuários em todo o mundo. Para isso, o Facebook conta com uma equipe integrada de desenvolvedores e operadores que trabalham em conjunto para planejar, testar, implantar e monitorar o software.

O Facebook também usa ferramentas como Phabricator, Buck e Mercurial para automatizar os processos de integração contínua (CI), entrega contínua (CD) e gerenciamento de versões do software. Com isso, o Facebook consegue entregar cerca de 50 mil atualizações por dia, em média, e obter um alto nível de inovação e experimentação do produto.

Um código de exemplo de como usar o Phabricator para criar um pipeline de integração contínua (CI) que executa os testes automatizados a cada commit no repositório de código é:

<?php

// This is an example of a Phabricator build plan for PHP projects.
// It uses Arcanist to run unit tests and lint checks on every commit.

$build_plan = new HarbormasterBuildPlan();
$build_plan->setName('PHP Build Plan');

// Step 1: Checkout the code from the repository
$step1 = new HarbormasterBuildStep();
$step1->setName('Checkout');
$step1->setImplementation('HarbormasterBuildStepImplementationSource');
$step1->setSetting('source.ref', 'refs/heads/master');
$build_plan->addStep($step1);

// Step 2: Run unit tests with Arcanist
$step2 = new HarbormasterBuildStep();
$step2->setName('Unit Tests');
$step2->setImplementation('HarbormasterBuildStepImplementationShellCommand');
$step2->setSetting('command', 'arc unit --everything');
$build_plan->addStep($step2);

// Step 3: Run lint checks with Arcanist
$step3 = new HarbormasterBuildStep();
$step3->setName('Lint Checks');
$step3->setImplementation('HarbormasterBuildStepImplementationShellCommand');
$step3->setSetting('command', 'arc lint --everything');
$build_plan->addStep($step3);

// Save the build plan
$id = $build_plan->save();

echo "Build plan created with ID {$id}.\n";

  • Feedback: o quinto passo é obter e fornecer feedback contínuo sobre o software, tanto internamente quanto externamente. Isso implica em coletar e analisar dados sobre o desempenho, a disponibilidade, a usabilidade e a satisfação do software, além de incorporar as sugestões e as reclamações dos usuários. Isso permite melhorar o produto de acordo com as necessidades e as preferências dos usuários, além de corrigir os problemas rapidamente.

Um exemplo de feedback com DevOps é o caso do Airbnb, uma empresa que oferece serviços de hospedagem e turismo. O Airbnb usa DevOps para entregar novas funcionalidades e correções para seus milhões de usuários em todo o mundo. Para isso, o Airbnb conta com uma equipe integrada de desenvolvedores e operadores que trabalham em conjunto para planejar, testar, implantar e monitorar o software.

O Airbnb também usa ferramentas como Datadog, Sentry e New Relic para coletar e analisar dados sobre o desempenho, a disponibilidade, a usabilidade e a satisfação do software. Com isso, o Airbnb consegue obter feedback em tempo real dos usuários e melhorar o produto continuamente.

Um código de exemplo de como usar o Datadog para coletar e visualizar dados sobre o desempenho do software é:

# This is an example of a Python script that uses the Datadog API to collect and visualize metrics about the response time of a web application.

# Import the Datadog library
from datadog import initialize, api

# Initialize the Datadog API with your API key and app key
options = {
    'api_key': 'YOUR_API_KEY',
    'app_key': 'YOUR_APP_KEY'
}

initialize(**options)

# Define a query to get the average response time of the web application in the last hour
query = "avg:webapp.response_time{*}"

# Get the result of the query as a JSON object
result = api.Metric.query(start=int(time.time()) - 3600, end=int(time.time()), query=query)

# Print the result
print(result)

# Create a time series graph to visualize the result
graph = {
    "title": "Web Application Response Time",
    "definition": {
        "requests": [
            {"q": query}
        ],
        "viz": "timeseries"
    }
}

# Save the graph to your Datadog dashboard
api.Graph.create(**graph)

  • Melhoria contínua: o sexto passo é buscar constantemente melhorar o software e os processos envolvidos na sua criação e manutenção. Isso implica em adotar uma mentalidade de aprendizado e experimentação, onde os problemas são vistos como oportunidades de melhoria e os erros são corrigidos rapidamente. Isso permite aprimorar o produto de forma incremental e adaptativa, além de aumentar a eficiência e a produtividade das equipes.

Um exemplo de melhoria contínua com DevOps é o caso do Google, uma empresa que oferece serviços de busca, publicidade, computação em nuvem e outros. O Google usa DevOps para entregar novas funcionalidades e correções para seus bilhões de usuários em todo o mundo. Para isso, o Google conta com uma equipe integrada de desenvolvedores e operadores que trabalham em conjunto para planejar, testar, implantar e monitorar o software.

O Google também usa ferramentas como Bazel, Kubernetes e TensorFlow para automatizar os processos de integração contínua (CI), entrega contínua (CD) e aprendizado de máquina (ML) do software. Com isso, o Google consegue realizar milhares de experimentos por dia, em média, além de melhorar o produto continuamente.

Um código de exemplo de como usar o TensorFlow para treinar e executar modelos de aprendizado de máquina (ML) que melhoram o produto com base nos dados dos usuários é:

# This is an example of a Python script that uses the TensorFlow library to train and run a neural network model for image classification.

# Import the TensorFlow library
import tensorflow as tf

# Load the MNIST dataset of handwritten digits
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Normalize the pixel values from 0-255 to 0-1
x_train, x_test = x_train / 255.0, x_test / 255.0

# Define the neural network model with two hidden layers and one output layer
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

# Define the loss function and the optimizer
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()

# Compile the model with the loss function and the optimizer
model.compile(loss=loss_fn, optimizer=optimizer, metrics=['accuracy'])

# Train the model with the training data for 5 epochs
model.fit(x_train, y_train, epochs=5)

# Evaluate the model with the test data
model.evaluate(x_test, y_test)

# Save the model to a file
model.save('my_model.h5')

# Load the model from the file
model = tf.keras.models.load_model('my_model.h5')

# Make predictions with the model on new images
predictions = model.predict(new_images)

# Print the predictions
print(predictions)

Conclusão

DevOps é uma cultura de desenvolvimento de software que visa integrar as equipes de desenvolvimento e operações, automatizar os processos de entrega e monitoramento e garantir a qualidade e a confiabilidade dos produtos. DevOps traz benefícios como melhoria da qualidade do software, aumento da velocidade de entrega, redução dos custos e aumento da satisfação dos clientes.

Para implementar DevOps na prática, é necessário definir uma visão compartilhada, estabelecer uma comunicação efetiva, automatizar os processos e seguir os princípios de colaboração, automação, entrega contínua, feedback e melhoria contínua.

Referências bibliográficas

💡
As opiniões e comentários expressos neste artigo são de propriedade exclusiva de seu autor e não representam necessariamente o ponto de vista da Revelo.

A Revelo Content Network acolhe todas as raças, etnias, nacionalidades, credos, gêneros, orientações, pontos de vista e ideologias, desde que promovam diversidade, equidade, inclusão e crescimento na carreira dos profissionais de tecnologia.