Esta página foi traduzida pela API Cloud Translation.
Switch to English

Excluir dados com uma função chamável do Cloud Functions

Veja nesta página como usar uma função chamável do Cloud Functions para excluir dados. Depois de implantar essa função, é possível chamá-la diretamente do app ou site para dispositivos móveis caso você queira excluir os documentos e coleções de maneira recorrente. Por exemplo, você pode usar essa solução para permitir que usuários selecionados excluam coleções inteiras.

Para outras formas de excluir coleções, consulte Excluir dados.

Solução: excluir dados com uma Função do Cloud chamável

Pode ser difícil implementar a exclusão de coleções inteiras de um app para dispositivos móveis com limitação de recursos devido aos seguintes motivos:

  • Nenhuma operação exclui atomicamente uma coleção.
  • A exclusão de um documento não remove os que estão nas subcoleções.
  • Se os seus documentos tiverem subcoleções dinâmicas, pode ser difícil saber quais dados devem ser excluídos de um determinado caminho.
  • A exclusão de uma coleção com mais de 500 documentos exige várias operações de gravação em lote ou centenas de exclusões únicas.
  • Em muitos apps, não é apropriado conceder permissão para que os usuários finais excluam coleções inteiras.

Você pode gravar uma Função do Cloud chamável para executar exclusões seguras e eficientes de coleções inteiras ou de árvores de coleção. A Função do Cloud abaixo implementa uma função chamável, o que significa que ela pode ser chamada diretamente do seu app para dispositivos móveis ou site, como você faria para uma função local.

Para implantar a função e testar uma demonstração, consulte o código de amostra.

Função do Cloud Functions

A função do Cloud Functions abaixo exclui uma coleção e todos os descendentes dela.

Em vez de implementar sua própria lógica de exclusão recorrente para sua Função do Cloud, você pode aproveitar o comando firestore:delete na interface de linha de comando (CLI) do Firebase. É possível importar qualquer função da Firebase CLI para seu aplicativo em Node.js próprio usando o pacote firebase-tools.

A Firebase CLI usa a API REST do Firestore para localizar todos os documentos no caminho especificado e excluí-los individualmente. Essa implementação não exige conhecimento da hierarquia de dados específica do seu app. Ela consegue até mesmo encontrar e excluir documentos "órfãos" que não têm mais um pai.

Node.js

/**
 * Initiate a recursive delete of documents at a given path.
 *
 * The calling user must be authenticated and have the custom "admin" attribute
 * set to true on the auth token.
 *
 * This delete is NOT an atomic operation and it's possible
 * that it may fail after only deleting some documents.
 *
 * @param {string} data.path the document or collection path to delete.
 */
exports.recursiveDelete = functions
  .runWith({
    timeoutSeconds: 540,
    memory: '2GB'
  })
  .https.onCall(async (data, context) => {
    // Only allow admin users to execute this function.
    if (!(context.auth && context.auth.token && context.auth.token.admin)) {
      throw new functions.https.HttpsError(
        'permission-denied',
        'Must be an administrative user to initiate delete.'
      );
    }

    const path = data.path;
    console.log(
      `User ${context.auth.uid} has requested to delete path ${path}`
    );

    // Run a recursive delete on the given document or collection path.
    // The 'token' must be set in the functions config, and can be generated
    // at the command line by running 'firebase login:ci'.
    await firebase_tools.firestore
      .delete(path, {
        project: process.env.GCLOUD_PROJECT,
        recursive: true,
        yes: true,
        token: functions.config().fb.token
      });

    return {
      path: path
    };
  });

Invocação do cliente

Para chamar a função, consiga uma referência à função do SDK do Firebase e transmita os parâmetros necessários:

Web
/**
 * Call the 'recursiveDelete' callable function with a path to initiate
 * a server-side delete.
 */
function deleteAtPath(path) {
    var deleteFn = firebase.functions().httpsCallable('recursiveDelete');
    deleteFn({ path: path })
        .then(function(result) {
            logMessage('Delete success: ' + JSON.stringify(result));
        })
        .catch(function(err) {
            logMessage('Delete failed, see console,');
            console.warn(err);
        });
}
Swift
    // Snippet not yet written
    
Objective-C
    // Snippet not yet written
    
Java
Android
/**
 * Call the 'recursiveDelete' callable function with a path to initiate
 * a server-side delete.
 */
public void deleteAtPath(String path) {
    Map<String, Object> data = new HashMap<>();
    data.put("path", path);

    HttpsCallableReference deleteFn =
            FirebaseFunctions.getInstance().getHttpsCallable("recursiveDelete");
    deleteFn.call(data)
            .addOnSuccessListener(new OnSuccessListener<HttpsCallableResult>() {
                @Override
                public void onSuccess(HttpsCallableResult httpsCallableResult) {
                    // Delete Success
                    // ...
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    // Delete failed
                    // ...
                }
            });
}
Kotlin+KTX
Android
/**
 * Call the 'recursiveDelete' callable function with a path to initiate
 * a server-side delete.
 */
fun deleteAtPath(path: String) {
    val deleteFn = Firebase.functions.getHttpsCallable("recursiveDelete")
    deleteFn.call(hashMapOf("path" to path))
            .addOnSuccessListener {
                // Delete Success
                // ...
            }
            .addOnFailureListener {
                // Delete Failed
                // ...
            }
}

Ao usar o SDK cliente para funções chamáveis do Cloud Functions, o estado de autenticação dos usuários e o parâmetro path são transmitidos sem interrupções para a função remota. Quando a função for concluída, o cliente receberá um retorno de chamada com o resultado ou uma exceção. Para saber mais sobre como chamar uma função do Cloud Functions no Android, iOS ou em outra plataforma, leia a documentação.

Limitações

A solução mostrada acima demonstra a exclusão de coleções de uma função chamável, mas fique atento às seguintes limitações:

  • Consistência: o código acima exclui um documento de cada vez. Se você fizer a consulta enquanto houver uma operação de exclusão em andamento, seus resultados poderão refletir um estado parcialmente completo, em que apenas alguns documentos de destino serão excluídos. Também não há garantia de que as operações de exclusão serão bem-sucedidas ou falharão de maneira uniforme. Portanto, prepare-se para lidar com casos de exclusão parcial.
  • Tempos limite: a função acima está configurada para ser executada por um máximo de 540 segundos antes do tempo limite. O código de exclusão pode remover 4.000 documentos por segundo no melhor dos casos. Se você precisar excluir mais de 2 milhões de documentos, execute a operação no seu próprio servidor para que ela não expire. Para ver um exemplo sobre como excluir uma coleção do seu próprio servidor, consulte Excluir coleções.