• 配置外部存储
• 提供私有静态对象
• 请求流示例
• 设置外部存储

静态对象的外部存储

将极狐GitLab 配置为从外部存储（例如内容交付网络 (CDN)）提供仓库静态对象（例如存档或原始 blob）。

配置外部存储

为静态对象配置外部存储：

1. 在左侧导航栏底部，选择 管理员。
2. 在左侧边栏中，选择 设置 > 仓库。
3. 展开 仓库静态对象的外部存储 部分。
4. 输入基本 URL 和任意令牌。当您设置外部存储时，使用将这些值设置为 ORIGIN_HOSTNAME 和 STORAGE_TOKEN 的脚本。
5. 选择 保存修改。

需要令牌来区分来自外部存储的请求，因此用户不会绕过外部存储直接访问应用程序。极狐GitLab 期望在源自外部存储的请求中的 X-Gitlab-External-Storage-Token 标头中设置此令牌。

提供私有静态对象

极狐GitLab 为属于私有项目的静态对象 URL 附加了用户特定的令牌，因此可以代表用户对外部存储进行身份验证。

在处理来自外部存储的请求时，极狐GitLab 会检查以下内容以确认用户可以访问请求的对象：

• token 查询参数。
• X-Gitlab-Static-Object-Token 标头。

请求流示例

以下示例显示了以下对象之间的一系列请求和响应：

• 用户。
• 极狐GitLab。
• 内容交付网络（CDN）。

设置外部存储

虽然此流程使用 Cloudflare Workers 作为外部存储，但其它 CDN 或 Function as a Service (FaaS) 系统应该使用相同的原理工作。

1. 如果您还没有这样做，请选择 Cloudflare Worker 域名。

2. 在以下脚本中，为前两个常量设置以下值：

   • ORIGIN_HOSTNAME：极狐GitLab 安装实例的主机名。

   • STORAGE_TOKEN：任意安全令牌。您可以通过在 UNIX 机器上运行 pwgen -cn1 64 来获取令牌。如配置部分中所述，将此令牌保存到管理中心。

     const ORIGIN_HOSTNAME = 'gitlab.installation.com' // FIXME: SET CORRECT VALUE
     const STORAGE_TOKEN = 'very-secure-token' // FIXME: SET CORRECT VALUE
     const CACHE_PRIVATE_OBJECTS = false
     
     const CORS_HEADERS = {
       'Access-Control-Allow-Origin': '*',
       'Access-Control-Allow-Methods': 'GET, HEAD, OPTIONS',
       'Access-Control-Allow-Headers': 'X-Csrf-Token, X-Requested-With',
     }
     
     self.addEventListener('fetch', event => event.respondWith(handle(event)))
     
     async function handle(event) {
       try {
         let response = await verifyAndHandle(event);
     
         // responses returned from cache are immutable, so we recreate them
         // to set CORS headers
         response = new Response(response.body, response)
         response.headers.set('Access-Control-Allow-Origin', '*')
     
         return response
       } catch (e) {
         return new Response('An error occurred!', {status: e.statusCode || 500})
       }
     }
     
     async function verifyAndHandle(event) {
       if (!validRequest(event.request)) {
         return new Response(null, {status: 400})
       }
     
       if (event.request.method === 'OPTIONS') {
         return handleOptions(event.request)
       }
     
       return handleRequest(event)
     }
     
     function handleOptions(request) {
       // Make sure the necessary headers are present
       // for this to be a valid pre-flight request
       if (
         request.headers.get('Origin') !== null &&
         request.headers.get('Access-Control-Request-Method') !== null &&
         request.headers.get('Access-Control-Request-Headers') !== null
       ) {
         // Handle CORS pre-flight request
         return new Response(null, {
           headers: CORS_HEADERS,
         })
       } else {
         // Handle standard OPTIONS request
         return new Response(null, {
           headers: {
             Allow: 'GET, HEAD, OPTIONS',
           },
         })
       }
     }
     
     async function handleRequest(event) {
       let cache = caches.default
       let url = new URL(event.request.url)
       let static_object_token = url.searchParams.get('token')
       let headers = new Headers(event.request.headers)
     
       url.host = ORIGIN_HOSTNAME
       url = normalizeQuery(url)
     
       headers.set('X-Gitlab-External-Storage-Token', STORAGE_TOKEN)
       if (static_object_token !== null) {
         headers.set('X-Gitlab-Static-Object-Token', static_object_token)
       }
     
       let request = new Request(url, { headers: headers })
       let cached_response = await cache.match(request)
       let is_conditional_header_set = headers.has('If-None-Match')
     
       if (cached_response) {
         return cached_response
       }
     
       // We don't want to override If-None-Match that is set on the original request
       if (cached_response && !is_conditional_header_set) {
         headers.set('If-None-Match', cached_response.headers.get('ETag'))
       }
     
       let response = await fetch(request, {
         headers: headers,
         redirect: 'manual'
       })
     
       if (response.status == 304) {
         if (is_conditional_header_set) {
           return response
         } else {
           return cached_response
         }
       } else if (response.ok) {
         response = new Response(response.body, response)
     
         // cache.put will never cache any response with a Set-Cookie header
         response.headers.delete('Set-Cookie')
     
         if (CACHE_PRIVATE_OBJECTS) {
           response.headers.delete('Cache-Control')
         }
     
         event.waitUntil(cache.put(request, response.clone()))
       }
     
       return response
     }
     
     function normalizeQuery(url) {
       let searchParams = url.searchParams
       url = new URL(url.toString().split('?')[0])
     
       if (url.pathname.includes('/raw/')) {
         let inline = searchParams.get('inline')
     
         if (inline == 'false' || inline == 'true') {
           url.searchParams.set('inline', inline)
         }
       } else if (url.pathname.includes('/-/archive/')) {
         let append_sha = searchParams.get('append_sha')
         let path = searchParams.get('path')
     
         if (append_sha == 'false' || append_sha == 'true') {
           url.searchParams.set('append_sha', append_sha)
         }
         if (path) {
           url.searchParams.set('path', path)
         }
       }
     
       return url
     }
     
     function validRequest(request) {
       let url = new URL(request.url)
       let path = url.pathname
     
       if (/^(.+)(\/raw\/|\/-\/archive\/)/.test(path)) {
         return true
       }
     
       return false
     }
     

3. 使用此脚本创建一个新 worker。
4. 复制 ORIGIN_HOSTNAME 和 STORAGE_TOKEN 的值。 使用这些值为静态对象配置外部存储。