Nombres comodín

Descripción

gsutil admite comodines de URI para archivos, depósitos y objetos. Un ejemplo es este comando:

gsutil cp gs://bucket/data/abc* .

Este comando copia todos los objetos que comiencen con gs://bucket/data/abc seguidos de cualquier cantidad de caracteres dentro de ese subdirectorio.

Caracteres comodín

gsutil usa los siguientes comodines:

*
Coincide con cualquier cantidad de caracteres dentro del nivel del directorio actual. Por ejemplo, gs://my-bucket/abc/d* coincide con el objeto abc/def.txt, pero no con el objeto abc/def/g.txt.
**
Coincide con cualquier cantidad de caracteres a través de los límites del directorio. Cuando se usa como parte de una ruta de acceso del archivo local, el comodín ** siempre debe estar precedido de inmediato por un delimitador del directorio. Por ejemplo, my-directory/**.txt es válido, pero my-directory/abc** no lo es.
?
Coincide con un solo carácter. Por ejemplo, gs://bucket/??.txt solo coincide con objetos con dos caracteres seguidos de .txt.
[chars]
Coincide con cualquiera de los caracteres especificados. Por ejemplo, gs://bucket/[aeiou].txt coincide con objetos que contienen un solo carácter vocabulario seguido de .txt.
[char range]
Coincide con cualquiera de los rangos de caracteres. Por ejemplo, gs://bucket/[a-m].txt coincide con los objetos que contienen letras a, b, c, … o m, y terminan con .txt.

Puedes combinar comodines para proporcionar coincidencias más eficaces, por ejemplo:

gs://*/[a-m]??.j*g

Ten en cuenta que, a menos que tu comando incluya una marca para mostrar versiones de objetos no actuales en los resultados, estos comodines solo coinciden con versiones de objetos activos.

gsutil admite los mismos comodines para objetos y nombres de archivos. Por ejemplo:

gsutil cp data/abc* gs://bucket

coincide con todos los archivos que comienzan con abc en el directorio data del sistema de archivos local.

Comportamientos que pueden ser inesperados cuando se usan comodines

Existen varias maneras de usar comodines que pueden dar como resultado comportamientos inesperados:

  1. Cuando se usan comodines en los nombres de los depósitos, las coincidencias se limitan a los depósitos en el proyecto especificado en la marca -p. Algunos comandos, como gsutil rm, no admiten la marca -p. Si la marca -p no se puede usar o no se puede usar en un comando, las coincidencias se limitan a buckets en el proyecto predeterminado.

  2. Las shells (como bash y zsh) pueden intentar expandir los comodines antes de pasar los argumentos a gsutil. Si el comodín debía referirse a un objeto en la nube, esto puede generar errores inesperados de tipo "No encontrado" (p. ej., si la shell intenta expandir el comodín gs://my-bucket/* en la máquina local, no hay coincidencias con archivos locales y falla el comando).

    Ten en cuenta que algunas shells incluyen caracteres adicionales en sus grupos de caracteres comodín. Por ejemplo, si usas zsh con la opción extendedglob habilitada, se tratará a # como un carácter especial, lo que entra en conflicto con el uso de ese caracteres para hacer referencia a los objetos con versión (consulta Restaura las versiones de objetos no actuales para obtener un ejemplo).

    Para evitar estos problemas, encierra la expresión de comodín con comillas simples (en Linux) o comillas dobles (en Windows).

  3. Intentar especificar un nombre de archivo que contenga caracteres comodín no funcionará, ya que gsutil intentará expandir los caracteres comodín en lugar de usarlos como caracteres literales. Por ejemplo:

    gsutil cp './file[1]' gs://my-bucket
    

    hace que gsutil intente hacer coincidir la parte [1] como un comodín.

    Existe un problema abierto a fin de admitir un modo “sin procesar” para que gsutil proporcione una forma de funcionar con nombres de archivos que contengan caracteres comodín, pero, hasta que esa compatibilidad se implemente o a menos que eso suceda, no habrá forma de usar gsutil con esos nombres de archivo. Puedes usar un comodín para asignar un nombre a esos archivos, por ejemplo, si reemplazas el comando anterior por el siguiente:

    gsutil cp './file*1*' gs://my-bucket
    

    Sin embargo, ese enfoque puede ser difícil de usar en general.

Comportamiento diferente para los archivos “dot” en el sistema de archivos local

Con el comportamiento estándar de Unix, el comodín * solo coincide con los archivos que no comienzan con un carácter . (a fin de evitar confusiones con los directorios . y .. en todos los directorios de Unix). gsutil proporciona este mismo comportamiento cuando se usan comodines en un URI de sistema de archivos, pero no proporciona este comportamiento en los URI en la nube. Por ejemplo, el siguiente comando copia todos los objetos de gs://bucket1 a gs://bucket2:

gsutil cp gs://bucket1/* gs://bucket2

pero el siguiente comando solo copia los archivos que no comienzan con . del directorio dir a gs://bucket1:

gsutil cp dir/* gs://bucket1

Consideración de la eficiencia: Usa comodines en muchos objetos

Es más eficiente, más rápido y requiere menos tráfico de red usar comodines que tienen un prefijo de nombre de objeto sin comodín, como los siguientes:

gs://bucket/abc*.txt

Esto se contrapone a usar comodines como la primera parte del nombre del objeto, por ejemplo:

gs://bucket/*abc.txt

Esto se debe a que la solicitud de gs://bucket/abc*.txt le pide al servidor que vuelva a enviar el subconjunto de resultados cuyo nombre de objeto comienza con abc en la raíz del bucket y, luego, gsutil filtra la lista de resultados para objetos cuyos nombres terminan con .txt. Por el contrario, gs://bucket/*abc.txt solicita al servidor la lista completa de objetos en la raíz del bucket y, luego, filtra los objetos cuyos nombres terminan en abc.txt. Esta consideración de eficiencia se vuelve cada vez más evidente cuando usas buckets que contienen miles de objetos o más. A veces, es posible configurar los nombres de los objetos para que se ajusten a los patrones de coincidencia de comodines esperados, a fin de aprovechar la eficiencia de realizar solicitudes de prefijos del servidor. Consulta, por ejemplo, ayuda de gsutil sobre producción para ver un ejemplo de caso de uso concreto.

Consideración de la eficiencia: Usa comodines de mitad de ruta de acceso

Supongamos que tienes un bucket con estos objetos:

gs://bucket/obj1
gs://bucket/obj2
gs://bucket/obj3
gs://bucket/obj4
gs://bucket/dir1/obj5
gs://bucket/dir2/obj6

Si ejecutas el comando a continuación, ocurrirá lo siguiente:

gsutil ls gs://bucket/*/obj5

gsutil genera una lista de buckets de nivel superior delimitada por / y, luego, una lista de buckets para cada subdirectorio, lo que da como resultado un total de 3 listas de buckets:

GET /bucket/?delimiter=/
GET /bucket/?prefix=dir1/obj5&delimiter=/
GET /bucket/?prefix=dir2/obj5&delimiter=/

Cuantas más listas de buckets requiera tu comodín, más lento y costoso será. La cantidad de listas de depósitos necesarias aumenta según lo siguiente:

  • La cantidad de componentes del comodín (p. ej., “gs://bucket/a??b/c*/*/d” tiene 3 componentes de comodín)
  • La cantidad de subdirectorios que coinciden con cada componente
  • La cantidad de resultados (la paginación se implementa mediante una solicitud GET por cada 1,000 resultados y se especifican los marcadores para cada uno)

Si deseas usar un comodín de mitad de ruta de acceso, puedes intentar usar un comodín recurrente, por ejemplo:

gsutil ls gs://bucket/**/obj5

Esto coincidirá con más objetos que gs://bucket/*/obj5 (ya que abarca directorios), pero se implementa mediante una solicitud de lista de buckets sin delimitador (lo que significa una menor cantidad de solicitudes de buckets, a pesar de que enumera todo el bucket y se filtra de forma local, por lo que podría requerir una cantidad no trivial de tráfico de red).