* que el contenido que tu programa entregó al sistema sea escrito en el disco
* una operación de API remota
* que una operación de base de datos termine
* que una query de base de datos devuelva los resultados
* etc.

Como el tiempo de ejecución se consume principalmente esperando operaciones de <abbr title="Input and Output">I/O</abbr>, las llaman operaciones "I/O bound".

    /**
     * Named pipe status indicating the pipe is listening for connections.
     */
    public static final int STATUS_LISTENING = 2;

    /**
     * Named pipe status indicating the connection is established and operational.
     */
    public static final int STATUS_CONNECTION_OK = 3;

    /**
     * Named pipe status indicating the server end of the pipe is closed.
     */
    public static final int STATUS_SERVER_END_CLOSED = 4;

* host (in a podcast): host
* request (as in HTTP request): request
* response (as in HTTP response): response
* path operation function: path operation function (do not translate to "función de operación de ruta")
* path operation: path operation (do not translate to "operación de ruta")
* path (as in URL path): path (do not translate to "ruta")
* query (as in URL query): query (do not translate to "consulta")
* cookie (as in HTTP cookie): cookie

![Erasure](https://github.com/minio/minio/blob/master/docs/screenshots/erasure-code.jpg?raw=true)

## What is Bit Rot protection?

	QStats        InQueueMetric                        `json:"queueStats"`
	MRFStats      ReplicationMRFStats                  `json:"mrfStats"`
}

// getNodeQueueStats returns replication operational stats at the node level
func (r *ReplicationStats) getNodeQueueStats(bucket string) (qs ReplQNodeStats) {
	qs.NodeName = globalLocalNodeName
	qs.Uptime = UTCNow().Unix() - globalBootTime.Unix()

Es opcional usarlo, pero ahí es donde pondrías la identificación del usuario, por lo que lo estamos usando aquí.

JWT podría ser usado para otras cosas aparte de identificar un usuario y permitirle realizar operaciones directamente en tu API.

Por ejemplo, podrías identificar un "coche" o un "artículo de blog".

Luego, podrías agregar permisos sobre esa entidad, como "conducir" (para el coche) o "editar" (para el blog).

OpenAPI requiere que cada operation ID sea único a través de todas las *path operations*, por lo que FastAPI usa el **nombre de la función**, el **path**, y el **método/operación HTTP** para generar ese operation ID, porque de esa manera puede asegurarse de que los operation IDs sean únicos.

Pero te mostraré cómo mejorar eso a continuación. 🤓

The MinIO TLS STS API can be configured via MinIO's standard configuration API (i.e. using `mc admin config set/get`). Further, it can be configured via the following environment variables:

```

 * Helper class for managing crawler statistics and performance metrics.
 * This class provides functionality to track, record, and report statistics
 * about crawler operations including timing data, performance metrics, and
 * operational events. It uses an internal cache to maintain statistics
 * objects and provides methods to begin tracking, record events, and
 * finalize statistics collection.
 *
 */
public class CrawlerStatsHelper {

    /**

		metricsGroupOpts: opts,
	}
	const (
		Online  = 1
		Offline = 0
	)

	mg.RegisterRead(func(_ context.Context) []MetricV2 {
		var ml []MetricV2
		// common operational metrics for bucket replication and site replication - published
		// at cluster level
		if rStats := globalReplicationStats.Load(); rStats != nil {
			qs := rStats.getNodeQueueStatsSummary()