Tutorial sobre a utilização de pacotes do sistema

---

Este tutorial mostra como criar um serviço Cloud Run personalizado que transforma um parâmetro de entrada de descrição de um gráfico num diagrama no PNGformato de imagem. Usa o Graphviz e é instalado como um pacote do sistema no ambiente de contentores do serviço. O Graphviz é usado através de utilitários de linha de comandos para processar pedidos.

Objetivos

• Escreva e crie um contentor personalizado com um Dockerfile
• Escreva, crie e implemente um serviço do Cloud Run
• Use a utilidade Graphviz dot para gerar diagramas
• Teste o serviço publicando um diagrama de sintaxe DOT da coleção ou da sua própria criação

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

• Cloud Build
• Artifact Registry
• Cloud Run

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Antes de começar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

1. Ative a Cloud Run Admin API
2. Instale e inicialize a CLI gcloud.
3. Atualize os componentes:

   gcloud components update

Funções necessárias

Para receber as autorizações de que precisa para concluir o tutorial, peça ao seu administrador para lhe conceder as seguintes funções da IAM no seu projeto:

• Editor do Cloud Build (roles/cloudbuild.builds.editor)
• Administrador do Cloud Run (roles/run.admin)
• Criar contas de serviço (roles/iam.serviceAccountCreator)
• Utilizador da conta de serviço (roles/iam.serviceAccountUser)
• Consumidor de utilização do serviço (roles/serviceusage.serviceUsageConsumer)
• Administrador de armazenamento (roles/storage.admin)

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Nota: as funções básicas da IAM também podem conter autorizações para concluir o tutorial. Não deve conceder funções básicas num ambiente de produção, mas pode concedê-las num ambiente de desenvolvimento ou de teste.

Configurar predefinições do gcloud

Para configurar o gcloud com as predefinições do seu serviço do Cloud Run:

1. Defina o projeto predefinido:

   gcloud config set project PROJECT_ID

   Substitua PROJECT_ID pelo nome do projeto que criou para este tutorial.

2. Configure o gcloud para a região escolhida:

   gcloud config set run/region REGION

   Substitua REGION pela região do Cloud Run suportada à sua escolha.

Localizações do Cloud Run

O Cloud Run é regional, o que significa que a infraestrutura que executa os seus serviços do Cloud Run está localizada numa região específica e é gerida pela Google para estar disponível de forma redundante em todas as zonas dessa região.

O cumprimento dos requisitos de latência, disponibilidade ou durabilidade são fatores principais para selecionar a região onde os seus serviços do Cloud Run são executados. Geralmente, pode selecionar a região mais próxima dos seus utilizadores, mas deve considerar a localização dos outros Google Cloudprodutos usados pelo seu serviço do Cloud Run. A utilização Google Cloud de produtos em conjunto em várias localizações pode afetar a latência do seu serviço, bem como o custo.

O Cloud Run está disponível nas seguintes regiões:

Sujeito aos preços de Nível 1

• asia-east1 (Taiwan)
• asia-northeast1 (Tóquio)
• asia-northeast2 (Osaca)
• asia-south1 (Mumbai, Índia)
• europe-north1 (Finlândia) Baixo CO₂
• europe-north2 (Estocolmo) Baixo CO₂
• europe-southwest1 (Madrid) Baixo CO₂
• europe-west1 (Bélgica) Baixo CO₂
• europe-west4 (Países Baixos) Baixo CO₂
• europe-west8 (Milão)
• europe-west9 (Paris) Baixo CO₂
• me-west1 (Telavive)
• northamerica-south1 (México)
• us-central1 (Iowa) Baixo CO₂
• us-east1 (Carolina do Sul)
• us-east4 (Virgínia do Norte)
• us-east5 (Columbus)
• us-south1 (Dallas) Baixo CO₂
• us-west1 (Oregão) Baixo CO₂

Sujeito aos preços de Nível 2

• africa-south1 (Joanesburgo)
• asia-east2 (Hong Kong)
• asia-northeast3 (Seul, Coreia do Sul)
• asia-southeast1 (Singapura)
• asia-southeast2 (Jacarta)
• asia-south2 (Deli, Índia)
• australia-southeast1 (Sydney)
• australia-southeast2 (Melbourne)
• europe-central2 (Varsóvia, Polónia)
• europe-west10 (Berlim) Baixo CO₂
• europe-west12 (Turim)
• europe-west2 (Londres, Reino Unido) Baixo CO₂
• europe-west3 (Frankfurt, Alemanha)
• europe-west6 (Zurique, Suíça) Baixo CO₂
• me-central1 (Doha)
• me-central2 (Dammam)
• northamerica-northeast1 (Montreal) Baixo CO₂
• northamerica-northeast2 (Toronto) Baixo CO₂
• southamerica-east1 (São Paulo, Brasil) Baixo CO₂
• southamerica-west1 (Santiago, Chile) Baixo CO₂
• us-west2 (Los Angeles)
• us-west3 (Salt Lake City)
• us-west4 (Las Vegas)

Se já criou um serviço do Cloud Run, pode ver a região no painel de controlo do Cloud Run na Google Cloud consola.

OK

Obter o exemplo de código

Para obter o exemplo de código para utilização:

1. Clone o repositório da app de exemplo para a sua máquina local:

   Node.js

   git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

   Python

   git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

   Ir

   git clone https://github.com/GoogleCloudPlatform/golang-samples.git

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

   Java

   git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

2. Altere para o diretório que contém o código de exemplo do Cloud Run:

   Node.js

   cd nodejs-docs-samples/run/system-package/

   Python

   cd python-docs-samples/run/system-package/

   Ir

   cd golang-samples/run/system_package/

   Java

   cd java-docs-samples/run/system-package/

Visualizar a arquitetura

A arquitetura básica tem o seguinte aspeto:

Para a origem do diagrama, consulte a descrição do DOT

O utilizador faz um pedido HTTP ao serviço Cloud Run que executa um utilitário Graphviz para transformar o pedido numa imagem. Essa imagem é enviada ao utilizador como resposta HTTP.

Compreender o código

Definir a configuração do ambiente com o Dockerfile

Ponto-chave: use o Dockerfile para personalizar o seu ambiente com bibliotecas, utilitários, variáveis de ambiente, ficheiros de configuração e processos de arranque. Esta é a abordagem baseada em contentores para a "configuração do servidor".

O seu Dockerfile é específico do idioma e do ambiente de funcionamento base, como o Ubuntu, que o seu serviço vai usar.

O guia de início rápido de criação e implementação mostra vários Dockerfiles que podem ser usados como ponto de partida para criar um Dockerfile para outros serviços.

Este serviço requer um ou mais pacotes de sistema adicionais que não estão disponíveis por predefinição.

1. Abra o Dockerfile num editor.

2. Procure um extrato da Dockerfile RUN Esta declaração permite a execução de comandos de shell arbitrários para modificar o ambiente. Se o Dockerfile tiver várias fases, identificadas pela deteção de várias declarações FROM, é encontrado na última fase.

   Os pacotes específicos necessários e o mecanismo para os instalar variam consoante o sistema operativo declarado no contentor.

   Para obter instruções para o seu sistema operativo ou imagem base, clique no separador adequado.

   Debian/Ubuntu

   RUN apt-get update -y && apt-get install -y \
     graphviz \
     && apt-get clean

   Alpine

   O Alpine requer um segundo pacote para suporte de fontes.

   RUN apk --no-cache add graphviz

   Para determinar o sistema operativo da sua imagem de contentor, verifique o nome na declaração FROM ou num ficheiro README associado à sua imagem base. Por exemplo, se estender a partir de node, pode encontrar documentação e o elemento principal Dockerfile no Docker Hub.

3. Teste a personalização criando a imagem docker buildlocalmente ou com o Cloud Build.

Processar pedidos recebidos

O serviço de exemplo usa parâmetros do pedido HTTP recebido para invocar uma chamada de sistema que executa o comando de utilitário dot adequado.

No controlador HTTP abaixo, um parâmetro de entrada de descrição do gráfico é extraído da variável de cadeia de consulta dot.

As descrições dos gráficos podem incluir carateres que têm de ser codificados em URL para utilização numa string de consulta.

Node.js

app.get('/diagram.png', (req, res) => {
  try {
    const image = createDiagram(req.query.dot);
    res.setHeader('Content-Type', 'image/png');
    res.setHeader('Content-Length', image.length);
    res.setHeader('Cache-Control', 'public, max-age=86400');
    res.send(image);
  } catch (err) {
    console.error(`error: ${err.message}`);
    const errDetails = (err.stderr || err.message).toString();
    if (errDetails.includes('syntax')) {
      res.status(400).send(`Bad Request: ${err.message}`);
    } else {
      res.status(500).send('Internal Server Error');
    }
  }
});

Python

@app.route("/diagram.png", methods=["GET"])
def index():
    """Takes an HTTP GET request with query param dot and
    returns a png with the rendered DOT diagram in a HTTP response.
    """
    try:
        image = create_diagram(request.args.get("dot"))
        response = make_response(image)
        response.headers.set("Content-Type", "image/png")
        return response

    except Exception as e:
        print(f"error: {e}")

        # If no graphviz definition or bad graphviz def, return 400
        if "syntax" in str(e):
            return f"Bad Request: {e}", 400

        return "Internal Server Error", 500

Ir

// diagramHandler renders a diagram using HTTP request parameters and the dot command.
func diagramHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		log.Printf("method not allowed: %s", r.Method)
		http.Error(w, fmt.Sprintf("HTTP Method %s Not Allowed", r.Method), http.StatusMethodNotAllowed)
		return
	}

	q := r.URL.Query()
	dot := q.Get("dot")
	if dot == "" {
		log.Print("no graphviz definition provided")
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}

	// Cache header must be set before writing a response.
	w.Header().Set("Cache-Control", "public, max-age=86400")

	input := strings.NewReader(dot)
	if err := createDiagram(w, input); err != nil {
		log.Printf("createDiagram: %v", err)
		// Do not cache error responses.
		w.Header().Del("Cache-Control")
		if strings.Contains(err.Error(), "syntax") {
			http.Error(w, "Bad Request: DOT syntax error", http.StatusBadRequest)
		} else {
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		}
	}
}

Java

get(
    "/diagram.png",
    (req, res) -> {
      InputStream image = null;
      try {
        String dot = req.queryParams("dot");
        image = createDiagram(dot);
        res.header("Content-Type", "image/png");
        res.header("Content-Length", Integer.toString(image.available()));
        res.header("Cache-Control", "public, max-age=86400");
      } catch (Exception e) {
        if (e.getMessage().contains("syntax")) {
          res.status(400);
          return String.format("Bad Request: %s", e.getMessage());
        } else {
          res.status(500);
          return "Internal Server Error";
        }
      }
      return image;
    });

Tem de distinguir entre erros internos do servidor e entradas do utilizador inválidas. Este serviço de exemplo devolve um erro interno do servidor para todos os erros de linha de comandos, exceto se a mensagem de erro contiver a string syntax, que indica um problema de entrada do utilizador.

A gerar um diagrama

A lógica essencial da geração de diagramas usa a ferramenta de linha de comando dot para processar o parâmetro de entrada de descrição do gráfico num diagrama no formato de imagem PNG.

Node.js

// Generate a diagram based on a graphviz DOT diagram description.
const createDiagram = dot => {
  if (!dot) {
    throw new Error('syntax: no graphviz definition provided');
  }

  // Adds a watermark to the dot graphic.
  const dotFlags = [
    '-Glabel="Made on Cloud Run"',
    '-Gfontsize=10',
    '-Glabeljust=right',
    '-Glabelloc=bottom',
    '-Gfontcolor=gray',
  ].join(' ');

  const image = execSync(`/usr/bin/dot ${dotFlags} -Tpng`, {
    input: dot,
  });
  return image;
};

Python

def create_diagram(dot):
    """Generates a diagram based on a graphviz DOT diagram description.

    Args:
        dot: diagram description in graphviz DOT syntax

    Returns:
        A diagram in the PNG image format.
    """
    if not dot:
        raise Exception("syntax: no graphviz definition provided")

    dot_args = [  # These args add a watermark to the dot graphic.
        "-Glabel=Made on Cloud Run",
        "-Gfontsize=10",
        "-Glabeljust=right",
        "-Glabelloc=bottom",
        "-Gfontcolor=gray",
        "-Tpng",
    ]

    # Uses local `dot` binary from Graphviz:
    # https://graphviz.gitlab.io
    image = subprocess.run(
        ["dot"] + dot_args, input=dot.encode("utf-8"), stdout=subprocess.PIPE
    ).stdout

    if not image:
        raise Exception("syntax: bad graphviz definition provided")
    return image

Ir

// createDiagram generates a diagram image from the provided io.Reader written to the io.Writer.
func createDiagram(w io.Writer, r io.Reader) error {
	stderr := new(bytes.Buffer)
	args := []string{
		"-Glabel=Made on Cloud Run",
		"-Gfontsize=10",
		"-Glabeljust=right",
		"-Glabelloc=bottom",
		"-Gfontcolor=gray",
		"-Tpng",
	}
	cmd := exec.Command("/usr/bin/dot", args...)
	cmd.Stdin = r
	cmd.Stdout = w
	cmd.Stderr = stderr

	if err := cmd.Run(); err != nil {
		return fmt.Errorf("exec(%s) failed (%w): %s", cmd.Path, err, stderr.String())
	}

	return nil
}

Java

// Generate a diagram based on a graphviz DOT diagram description.
public static InputStream createDiagram(String dot) {
  if (dot == null || dot.isEmpty()) {
    throw new NullPointerException("syntax: no graphviz definition provided");
  }
  // Adds a watermark to the dot graphic.
  List<String> args = new ArrayList<>();
  args.add("/usr/bin/dot");
  args.add("-Glabel=\"Made on Cloud Run\"");
  args.add("-Gfontsize=10");
  args.add("-Glabeljust=right");
  args.add("-Glabelloc=bottom");
  args.add("-Gfontcolor=gray");
  args.add("-Tpng");

  StringBuilder output = new StringBuilder();
  InputStream stdout = null;
  try {
    ProcessBuilder pb = new ProcessBuilder(args);
    Process process = pb.start();
    OutputStream stdin = process.getOutputStream();
    stdout = process.getInputStream();
    // The Graphviz dot program reads from stdin.
    Writer writer = new OutputStreamWriter(stdin, "UTF-8");
    writer.write(dot);
    writer.close();
    process.waitFor();
  } catch (Exception e) {
    System.out.println(e);
  }
  return stdout;
}

Conceber um serviço seguro

Quaisquer vulnerabilidades na ferramenta dot são potenciais vulnerabilidades do serviço Web. Pode mitigar esta situação usando versões atualizadas do pacote graphviz através da recompilação da imagem do contentor de forma regular.

Se estender o exemplo atual para aceitar a entrada do utilizador como parâmetros da linha de comandos, deve proteger-se contra ataques de injeção de comandos. Algumas das formas de evitar ataques de injeção incluem:

• Mapeamento de entradas para um dicionário de parâmetros suportados
• Validar se as entradas correspondem a um intervalo de valores conhecidos e seguros, talvez usando expressões regulares
• Escape às entradas para garantir que a sintaxe da shell não é avaliada

Pode mitigar ainda mais potenciais vulnerabilidades implementando o serviço com uma conta de serviço à qual não foram concedidas autorizações para usar serviços Google Cloud, em vez de usar a conta predefinida, que tem autorizações usadas com frequência. Por esse motivo, os passos neste tutorial criam e usam uma nova conta de serviço.

Envio do código

Para enviar o seu código, crie-o com o Cloud Build, carregue-o para o Artifact Registry e implemente-o no Cloud Run:

1. Crie um Artifact Registry:

   gcloud artifacts repositories create REPOSITORY \
       --repository-format docker \
       --location REGION

   Substituir:

   • REPOSITORY: um nome exclusivo para o repositório. Para cada localização do repositório num projeto, os nomes dos repositórios têm de ser exclusivos.
   • REGION: a Google Cloud região a usar para o repositório do Artifact Registry.

2. Execute o seguinte comando para criar o contentor e publicar no Artifact Registry.

   Node.js

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/graphviz

   Onde PROJECT_ID é o ID do seu Google Cloud projeto e graphviz é o nome que quer dar ao seu serviço.

   Após a conclusão com êxito, é apresentada uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se quiser.

   Python

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/graphviz

   Onde PROJECT_ID é o ID do seu Google Cloud projeto e graphviz é o nome que quer dar ao seu serviço.

   Após a conclusão com êxito, é apresentada uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se quiser.

   Ir

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/graphviz

   Onde PROJECT_ID é o ID do seu Google Cloud projeto e graphviz é o nome que quer dar ao seu serviço.

   Após a conclusão com êxito, é apresentada uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se quiser.

   Java

   Este exemplo usa o Jib para criar imagens do Docker com ferramentas Java comuns. O Jib otimiza as compilações de contentores sem precisar de um Dockerfile nem ter o Docker instalado. Saiba mais sobre como criar contentores Java com o Jib.

   1. Usando o Dockerfile, configure e crie uma imagem de base com os pacotes do sistema instalados para substituir a imagem de base predefinida do Jib:

      # Use the Official eclipse-temurin image for a lean production stage of our multi-stage build.
      # https://hub.docker.com/_/eclipse-temurin/
      FROM eclipse-temurin:17.0.15_6-jre
      
      RUN apt-get update -y && apt-get install -y \
        graphviz \
        && apt-get clean

      gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/graphviz-base

      Onde PROJECT_ID é o ID do seu Google Cloud projeto.

   2. Use o auxiliar de credenciais gcloud para autorizar o Docker a enviar para o seu Artifact Registry.

      gcloud auth configure-docker

   3. Crie o contentor final com o Jib e publique-o no Artifact Registry:

      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>3.4.0</version>
        <configuration>
          <from>
            <image>gcr.io/PROJECT_ID/graphviz-base</image>
          </from>
          <to>
            <image>gcr.io/PROJECT_ID/graphviz</image>
          </to>
        </configuration>
      </plugin>

      mvn compile jib:build \
       -Dimage=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/graphviz \
       -Djib.from.image=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/graphviz-base

      Onde PROJECT_ID é o ID do seu Google Cloud projeto.

3. Implemente através do seguinte:

   gcloud

   1. Crie uma nova conta de serviço. O seu código, incluindo todos os pacotes do sistema que usa, só pode usar os serviçosGoogle Cloud que foram concedidos a esta conta de serviço.

      gcloud iam service-accounts create SA_NAME

      Em que SA_NAME é um nome que atribui a esta conta de serviço. Se existir um erro ou uma vulnerabilidade no seu código, o código não vai poder aceder a nenhum dos outros recursos do projeto. Google Cloud
   2. Implemente o código, especificando a conta de serviço.

      gcloud run deploy graphviz-web --service-account SA_NAME@PROJECT_ID.iam.gserviceaccount.com  --image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/graphviz

      Onde PROJECT_ID é o seu ID do projeto, Google Cloud é o nome da conta de serviço que criou, graphviz é o nome do contentor acima, e graphviz-web é o nome do serviço.SA_NAME Responda Y ao comando "allow unauthenticated" (permitir não autenticado). Consulte o artigo Gerir acesso para ver mais detalhes sobre a autenticação baseada na IAM.
   3. Aguarde até que a implementação esteja concluída. Esta operação pode demorar cerca de meio minuto. Se for bem-sucedido, a linha de comandos apresenta o URL do serviço.

   Terraform

   Para saber como aplicar ou remover uma configuração do Terraform, consulte os comandos básicos do Terraform.

   O código do Terraform seguinte cria um serviço do Cloud Run.

   resource "google_service_account" "graphviz" {
     account_id   = "graphviz"
     display_name = "GraphViz Tutorial Service Account"
   }
   
   resource "google_cloud_run_v2_service" "default" {
     name     = "graphviz-example"
     location = "us-central1"
   
     deletion_protection = false # set to "true" in production
   
     template {
       containers {
         # Replace with the URL of your graphviz image
         #   gcr.io/<YOUR_GCP_PROJECT_ID>/graphviz
         image = "us-docker.pkg.dev/cloudrun/container/hello"
       }
   
       service_account = google_service_account.graphviz.email
     }
   }

   Substitua IMAGE_URL por uma referência à imagem do contentor, por exemplo, us-docker.pkg.dev/cloudrun/container/hello:latest. Se usar o Artifact Registry, o repositório REPO_NAMEtem de já estar criado. O URL segue o formato LOCATION-docker.pkg.dev/PROJECT_ID/REPO_NAME/PATH:TAG .

   O código do Terraform seguinte torna o seu serviço do Cloud Run público.

   # Make Cloud Run service publicly accessible
   resource "google_cloud_run_service_iam_member" "allow_unauthenticated" {
     service  = google_cloud_run_v2_service.default.name
     location = google_cloud_run_v2_service.default.location
     role     = "roles/run.invoker"
     member   = "allUsers"
   }

4. Se quiser implementar uma atualização de código no serviço, repita os passos anteriores. Cada implementação num serviço cria uma nova revisão e começa automaticamente a publicar tráfego quando estiver pronta.

Experimentar

Experimente o seu serviço enviando pedidos HTTP POST com descrições de sintaxe DOT no payload do pedido.

1. Envie um pedido HTTP para o seu serviço.

   Copie o URL para a barra de URL do navegador e atualize [SERVICE_DOMAIN]:

   https://SERVICE_DOMAIN/diagram.png?dot=digraph Run { rankdir=LR Code -> Build -> Deploy -> Run }

   Pode incorporar o diagrama numa página Web:

   <img src="https://SERVICE_DOMAIN/diagram.png?dot=digraph Run { rankdir=LR Code -> Build -> Deploy -> Run }" />

2. Abra o ficheiro diagram.png resultante em qualquer aplicação que suporte ficheiros PNG, como o Chrome.

   Deve ter esta forma:

   

   Fonte: Descrição do DOT

Pode explorar uma pequena coleção de descrições de diagramas prontas.

1. Copie o conteúdo do ficheiro .dot selecionado

2. Envie um pedido HTTP para o seu serviço.

   Copie o URL para a barra de URL do navegador

   https://SERVICE_DOMAIN/diagram.png?dot=SELECTED DOTFILE CONTENTS

   Êxito: implementou um serviço do Cloud Run personalizado que transforma um parâmetro de entrada de descrição de um gráfico num diagrama no formato de imagem PNG.

Limpar

Se criou um novo projeto para este tutorial, elimine o projeto. Se usou um projeto existente e quer mantê-lo sem as alterações adicionadas neste tutorial, elimine os recursos criados para o tutorial.

Eliminar o projeto

A forma mais fácil de eliminar a faturação é eliminar o projeto que criou para o tutorial.

Para eliminar o projeto:

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminar recursos do tutorial

1. Elimine o serviço do Cloud Run que implementou neste tutorial:

   gcloud run services delete SERVICE-NAME

   Onde SERVICE-NAME é o nome do serviço escolhido.

   Também pode eliminar serviços do Cloud Run a partir da Google Cloud consola.

2. Remova a configuração da região predefinida do gcloud que adicionou durante a configuração do tutorial:

    gcloud config unset run/region
   

3. Remova a configuração do projeto:

    gcloud config unset project
   

4. Elimine outros Google Cloud recursos criados neste tutorial:

   • Elimine a imagem do contentor denominada REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/graphviz do Artifact Registry.

   • Elimine a conta de serviço SA_NAME.

     gcloud iam service-accounts delete SA_NAME@PROJECT_ID.iam.gserviceaccount.com

O que se segue?

• Experimente a sua app Graphviz:
  • Adicionar suporte para outras utilidades do Graphviz que aplicam algoritmos diferentes à geração de diagramas.
  • Guarde diagramas no Cloud Storage. Quer guardar a imagem ou a sintaxe DOT?
  • Implemente a proteção contra abuso de conteúdo com a API Cloud Natural Language.
  • Veja outro exemplo de um pacote do sistema no tutorial de processamento de imagens com o Cloud Run.
• Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.