private enum Timeout {
    MIN(Long.MIN_VALUE, "-oo"),
    MINUS_SMALL(-SMALL_TIMEOUT_MILLIS, "-" + SMALL_TIMEOUT_MILLIS + "ms"),
    ZERO(0L, "0ms"),
    SMALL(SMALL_TIMEOUT_MILLIS, SMALL_TIMEOUT_MILLIS + "ms"),
    LARGE(UNEXPECTED_HANG_DELAY_MILLIS * 2, (2 * UNEXPECTED_HANG_DELAY_MILLIS) + "ms"),
    MAX(Long.MAX_VALUE, "+oo");

    final long millis;
    final String label;

    Timeout(long millis, String label) {

			// in obtaining service accounts by this cred.
			cred.ParentUser = lookupResult.NormDN

			// Set this value to LDAP groups, LDAP user can be part
			// of large number of groups
			cred.Groups = targetGroups

			// Set the newly generated credentials, policyName is empty on purpose
			// LDAP policies are applied automatically using their ldapUser, ldapGroups
			// mapping.

* Allez dans le répertoire de votre projet.
* Créez un `Dockerfile` avec :

```Dockerfile
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7

COPY ./app /app
```

### Applications plus larges

Si vous avez suivi la section sur la création d' [Applications avec plusieurs fichiers](../tutorial/bigger-applications.md){.internal-link target=_blank}, votre `Dockerfile` pourrait ressembler à ceci :

```Dockerfile

		if field == nil {
			continue
		}

		if len(joinFields) == 0 || len(joinFields[idx]) == 0 {
			db.AddError(field.Set(db.Statement.Context, reflectValue, values[idx]))
		} else { // joinFields count is larger than 2 when using join
			var isNilPtrValue bool
			var relValue reflect.Value
			// does not contain raw dbname
			nestedJoinSchemas := joinFields[idx][:len(joinFields[idx])-1]
			// current reflect value

//
//   - <KbBlockSize>
//     Veeam Block Size for backup and restore processing before compression is applied. The higher the block size, the more
//     backup space is needed for incremental backups. Larger block sizes also mean less performance for random read restore
//     methods like Instant Restore, File Level Recovery, and Database/Application restores. Veeam recommends that vendors

        FileBothDirectoryInfo result = (FileBothDirectoryInfo) createFileInfoMethod.invoke(response);

        assertNull(result);
    }

    @Test
    @DisplayName("Test readBytesWireFormat handles large buffer offset correctly")
    void testReadBytesWireFormatLargeBufferOffset() throws Exception {
        response = new Smb2QueryDirectoryResponse(mockConfig, Smb2QueryDirectoryRequest.FILE_BOTH_DIRECTORY_INFO);

    }

    /**
     * Test edge case with maximum data size
     */
    @Test
    @DisplayName("Handle large data size")
    void testLargeDataSize() throws CIFSException {
        // Create a large data array
        byte[] largeData = new byte[1024];
        Arrays.fill(largeData, (byte) 0xFF);

        byte[] avPairData = createAvPairData(0x99, largeData);

         * than a handful of exceptions. But it seems prudent to set a cap on how many we'll cache.
         * This avoids out-of-control memory consumption, and it keeps the cache from growing so
         * large that doing the lookup is noticeably slower than redoing the work would be.
         *
         * Ideally we'd have a real eviction policy, but until we see a problem in practice, I hope

        }
        return (T) field;
    }

    /**
     * Iterates through all access results for a session, calling the callback for each result.
     * Uses OpenSearch scroll API for efficient iteration over large result sets.
     *
     * @param sessionId The session ID.
     * @param callback The callback to execute for each access result.
     */
    @Override

            System.arraycopy(data, offset, result, 0, length);
            return result;
        }
        if (length > MAX_COMPRESSION_SIZE) {
            throw new CIFSException("Data too large for compression: " + length + " bytes");
        }

        switch (algorithm) {
        case COMPRESSION_NONE:
            byte[] uncompressed = new byte[length];