Publish hosted tile layers

Tile layers published to and hosted on your portal support fast visualization of large datasets using a collection of predrawn map images or tiles. Hosted tiles provide geographic context for your operational layers. For example, you might include tiles of streets in your neighborhood to provide a visual reference for the street signs in your feature layer.

You can publish a tile layer to be hosted on your portal using any of the following methods:

• Define a map in ArcMap and allow your portal to create the tiles.
• Define a map in ArcGIS Pro and allow your portal to create the tiles.
• Build and share a tile package in ArcMap and publish in your portal.
• Build a tile package in ArcGIS Pro, upload and publish to your portal.
• Create tiles for an existing hosted feature layer.
• Define a service definition file in ArcMap, upload it, and allow your portal to create the tiles.

You can build a cache on your tiles automatically when publishing, or build the cache manually after publishing. See Best practices for tile caches for more information.

You must have privileges to create content and publish hosted tile layers to publish a map or service definition file as a hosted tile layer.

Define and publish a map in ArcMap

From ArcMap, you can publish a tile layer to be hosted on your portal.

Be sure ArcGIS Desktop is connected to your portal before you start ArcMap.

1. Start ArcMap and open the map you want to publish.
2. Sign in to your portal with an account that has privileges to create content and publish hosted tile layers.
   1. Click File > Sign In.
   2. Type your user name and password for your portal and click Sign In.
Now, publish the map.
3. Click File > Share As > Service.
4. Choose Publish a service and click Next.

   Caution:

   If you choose to overwrite the service instead, the existing map tile item is deleted from the portal and a new item is created with the same name. The new item is created in the root folder and the item is assigned a new ID. You must reconfigure sharing and, if necessary, move the item back to the folder it was in before you republished.

5. In the drop-down list of connection types, choose My Hosted Services. Then type a name for your tiles and click Continue.
6. Set the properties you want in the Service Editor. Here, you can choose what users can do with your tiles, and take fine-grained control of how the server will expose them.

   For information on how to best configure your tiles for deployment, see Tuning and configuring services in the ArcGIS Server help. Some of the properties referenced in that topic apply only to ArcGIS Server and are not applicable when working with hosted tile layers.

   Tip:

   If you close the Service Editor during this session, you'll be prompted to save your work as a draft service. Draft services allow you to come back to your service configuration work at a later time. By default, draft services are saved in the Drafts folder of your connection to My Hosted Maps. For more information, see About draft services in the ArcGIS Server help.

There are a few properties you need to set that are specific to hosted tile layers. These are detailed in the following steps.
7. In the left pane of the Service Editor, click Capabilities, and check Tiled Mapping to expose your map as a tile layer. Check Feature Access to publish a feature layer with your tiles if you want to configure pop-ups for the layer when you add it to the map viewer.

   You can click the subitem Tiled Mapping in the left pane of the Service Editor to set advanced properties relating to what clients can do with the published tile layer.

8. Click the Caching item to set properties for the tile cache. See Creating a map cache in the ArcGIS Server help for more detailed steps, keeping in mind that some of the advanced caching settings are only available when publishing directly to ArcGIS Server.
9. In the left pane of the Service Editor, click Item Description and provide a summary and tags for your tile layer. You'll need to enter this information before you can publish. For more information, see the item description section in Setting map service properties in the ArcGIS Server help.
10. In the left pane of the Service Editor, click Sharing, and choose with whom the hosted tile layer should be shared. By default, your hosted tile layer is shared to My Content only, meaning it is only accessible to you. Your tile layer will always be visible in My Content, but you can also choose to share it with everyone, members of your organization, or just members of certain groups.
11. In the Service Editor, click Analyze .

    This examines your map to see if it can be published. You must fix the Errors in the Prepare window before you can publish. Optionally, you can fix the warnings and informational messages to further improve the performance and appearance of your published tiles. For more information about resolving these issues, see Analyzing your GIS resource in the ArcGIS Server help.

12. Optionally click Preview in the Service Editor. This can give you an idea of how your tile layer will look when viewed on the web.
13. Once you've fixed the errors and optionally any warnings and messages, click Publish .

    Note:

    Your data is copied to the server at this point. The size of the data and your network connection speed and bandwidth will impact the time it takes to publish. You should also budget some time for your tiles to be generated.

Once your tile layer is published to your portal, you'll see them when you expand the My Hosted Services node in the Catalog window.

Your hosted tile layer is listed as two independent items on the My Content page of the portal website: Tiles and a Service Definition. A service definition is a zipped file containing the map, its data, and details about how the tiles should be published. A service definition can be transferred and published to any machine running ArcGIS Server.

Define and publish a map in ArcGIS Pro

From a map in ArcGIS Pro, you can publish a tile layer to be hosted on your portal.

Also note that web browsers cannot display some of the more complex cartographic symbols you might have originally used when you authored the map. Most symbol types are available, but in some cases, the symbols may be downgraded when you publish them. See Author feature services in the ArcGIS Server help for more details about what symbols are supported, and make any required changes to your map symbology prior to publishing.

1. Start ArcGIS Pro and open the project that contains the map you want to publish.
2. Be sure your portal connection is active and sign in to your organization using an account that has privileges to create content and publish hosted tile layers.
3. To publish a tile layer, do one of the following:
   • Select the layers in the Contents pane. Right-click the selection set and click Share As Web Layer.

   • To publish all the layers in the map, click Web Layer in the Share As group of the Share tab and click Publish Web Layer.

   Tip:

   If the Share As Web Layer menu option is not active, it could be due to one of the following:

   • The account you signed in with does not have privileges to publish hosted layers.
   • Your portal is not configured with a hosting server, which is required to host web layers.
   • You're trying to publish a multipatch layer, which is not supported.

4. Type a name for the tile layer. The layer is saved to My Content by default. You can save to a folder within My Content by either typing the folder name or browsing to an existing folder.
5. Choose to Copy all data.
6. Choose Tile for the Layer Type.

   This automatically unchecks other Layer Type options, as only one can be checked at a time when copying data.

7. Provide a summary and tags for the tile layer.
8. Specify how the tile layer will be shared. All layers you publish are automatically shared to your personal workspace in your organization (My Content). Your content is inaccessible to others until you share it with one or more of the following:
   • The name of your portal— Choosing this option allows the layer to be shared with all authenticated users in the portal.
   • Everyone—Choosing this option makes the layer available to anyone who can access your portal.
   • Groups—You can share the layer with members of groups to which you belong.
9. Click the Configuration and click the Configure Web Layer Properties button to specify cache settings.
10. Choose a Tiling Scheme.
11. Resize and drag the Levels of Detail bar to indicate minimum and maximum scale for your tile layer.

    The estimated size of the resultant cache changes as you change the minimum and maximum scale.

12. Choose when and where to build the tile cache.
    • Choose Cache automatically on the server if you want the tiles to be built on the portal's hosting server when you publish the layer.
    • If you want the cache built and stored on the portal's hosting server, but you want to build them yourself after publishing, choose Cache manually on the server, open the tile layer in the portal website after the layer is published, and manually create the cache.
    • Choose Cache locally and specify a location on the ArcGIS Pro machine to store a temporary tile package if you want the cache to be built and packaged on the ArcGIS Pro machine. The tile package will be automatically uploaded to the portal's hosting server to be unpacked and the cache stored there.
13. To allow people to download map tiles for use offline, check Allow clients to export cache tiles.
14. If you checked Allow clients to export cache tiles, use the Limit export to field to specify the maximum number of tiles clients can take offline at one time.
15. Click the Content tab to confirm the tile layer will include the data layers you intended.
16. Click Analyze to check for any errors or issues.

    If any issues are discovered, they will be listed on the Messages tab. Right-click each message to get more information, read help for the error or warning, and access suggested fixes. You must fix the errors before you can publish. Optionally, you can fix the warnings to further improve the performance and appearance of your hosted tile layer.

17. Once you've fixed the errors and optionally any warnings, click Publish.

    Note:

    Your data is copied to the server at this point. The size of the data and your network speed and bandwidth will impact the time it takes to publish.

When publishing completes, you can click Manage the web layer to open the portal website.

Build and share a tile package in ArcMap and publish

ArcMap allows you to build tiles for a map document and store them in an easily transferrable tile package (.tpk) file. You can create a tile package in ArcMap, share it to your portal, and publish it as a hosted tile layer.

Two different workflows are described below. The first can be used for small to moderately sized tile packages and will preserve elements of the map document, such as the legend and text elements, when the tiles are published from the tile package. The second workflow is recommended when publishing large tile packages but maintains only the data when tiles are published from the tile package.

Follow these steps to publish a small to moderately sized tile package:

1. Open your map in ArcMap.
2. Sign in to your portal with an account that has privileges to create content and publish hosted tile layers.
3. Click Customize > ArcMap Options > Sharing and ensure that Enable ArcGIS Runtime tools is checked.

   This enables the menu option you'll use in the next step.

4. In ArcMap, click File > Share As > Tile Package.
5. Configure all the settings in the substeps below. Other settings are left to your choosing.
   1. On the Tile Package tab, choose Upload package to my ArcGIS Portal account.
   2. On the Tile Format tab, choose ArcGIS Online / Bing Maps / Google Maps as the Tiling Scheme.
   3. On the Item Description tab, provide the items marked as required.
   4. On the Sharing tab, you can choose to share the package with the public or specific groups.
6. Click Share.

   You may be prompted to save your map before the tile package can be created.

   It can take a while for a tile package to be generated, especially if you have included large scales.

7. When your tile package has finished generating, sign in to your portal using the same account you used when you created the tile package in ArcMap and click My Content.
8. Click your tile package to display its item details page.
9. Click Publish.
10. Type a title and tags and click Publish.

The tiles are unpacked and a hosted tile layer is created on your portal. You should be able to see the map tiles in My Content.

To build and share large tile packages, Esri recommends that you use the Tile Cache toolset instead of using the previous workflow. These tools can take advantage of multiple processing cores.

Execute these tools in the following order:

1. Run Generate Tile Cache Tiling Scheme to define the tiling grid and image format.
2. Run Manage Tile Cache to build the tiles.
3. Run Export Tile Cache to create the tile package.
4. Run Share Package (in the Package toolset) to upload the tiles onto your portal.

Note that you will have to specify a feature layer with the hosted tile layer if you want to configure pop-ups.

Build a tile package in ArcGIS Pro and upload to your organization

Use the Create Map Tile Package geoprocessing tool to create a tile package, add the package to your organization, and publish a tile layer.

1. Open the project that contains the data you want to package.
2. Open and run the Create Map Tile Package geoprocessing tool.
3. When your tile package has finished generating, sign in to your portal using an account privileges to create content and publish hosted tile layers, and click My Content.
4. Add the tile package From my computer.
5. Check the box to Publish this file as a hosted layer.
6. Type a title and tags and click Add Item.

The tiles are unpacked and a hosted tile layer is created on your portal. You should be able to see the map tiles and tile package in My Content.

Publish from a hosted feature layer

You can publish a hosted tile layer to your portal using an existing hosted feature layer that you own if your portal's hosting server uses a relational data store created through ArcGIS Data Store. This is a useful workflow to visualize large datasets.

Note:

• Edits to spatial attributes made to the hosted feature layer are not automatically reflected in the hosted tile layer. You must republish the hosted tile layer from the updated hosted feature layer.
• There are styling restrictions on the hosted feature layer that could prevent you from publishing a hosted tile layer.
• You cannot publish a hosted tile layer from a multipatch or point cloud hosted feature layer.

Follow these steps to publish a hosted tile layer from a hosted feature layer:

1. Sign in with an account that has privileges to publish hosted tile layers, and click My Content.
2. To publish, do one of the following:
   • Click the hosted feature layer you want to publish and click Publish.
   • Click Create > Tile Layer and choose a Feature Layer to publish as tiles.
3. Type a title, tags, and summary, and choose a folder for the hosted tile layer.
4. Optionally change the extents at which the layer will display by dragging the end points of the Visible Range.

   Caution:

   Portal for ArcGIS presents you with a suggested scale range, but you can modify that. Be aware, though, that including large scales in your scale range can vastly increase the resources consumed on your server. Don't create tiles beyond the precision of your data.

5. Click OK.

   The hosted tile layer is created and its item page appears.

Publish from a service definition file

Publishing tiles and building a cache can use a lot of server resources. If you need to publish a large number of tile layers, your map authors could create service definition (.sd) files in ArcMap that contain all the information needed to publish a tile layer to the portal. You could then use a script to upload and publish the service definition files to your portal after business hours. The resultant tile layers will be hosted on your portal's hosting server.

Create a service definition file

The map author should follow these steps to create a service definition file containing the data and symbology required for a tile layer that will be hosted on the portal.

1. Start ArcMap and sign in to the portal.
2. Create and save a map.

   For information on creating and publishing a map, see the map service topics in the ArcGIS Server help.

Now, create a service definition file.
3. Click File > Share As > Service.
4. Choose to Save a service definition file and click Next.
5. Click Choose a connection and choose My Hosted Services from the drop-down list.
6. Type a name for the file and click Next.
7. Specify in which directory on the client machine to create the service definition file and click Continue.

   The Service Editor opens.

8. In the left pane of the Service Editor, click Caching.
9. Choose a Tiling Scheme.
10. Choose the minimum and maximum scales for the tiles and Calculate Cache Size.
11. Click Build cache manually after the service is published.
12. Optionally, click Advanced Settings and set additional cache settings for the tile cache.
13. In the left pane of the Service Editor, click Item Description and provide information for your tile layer.

    You must provide at least a summary and tags before you can create the service definition file.

14. Click Analyze to be sure there are no errors.

    You must fix any errors before you can stage the service definition file. Optionally, you can make corrections for any warnings and messages returned.

15. Once you've fixed the errors and optionally any warnings and messages, click Stage .

The service definition file is saved in the location you specified.

Load the service definition and publish

Once you obtain the service definition file from the author, you can either manually upload it to My Content in your portal and publish a tile layer, or schedule a script to upload and publish the file.

Manually upload and publish

Sign in to the portal website to add and publish the service definition file to your portal.

1. Sign in to your portal as a member with privileges to create content and publish hosted tile layers, and open My Content.
2. Click Add Item.
3. Choose to load the file from your computer.
4. Click the browse button and choose the service definition file.
5. Check Publish this file as a service.
6. Type tag terms separated by commas.

   Tags are words or short phrases that describe your item and improve its findability. Federal land is considered one tag, while Federal,land is considered two tags.

7. Click Add Item to add the service definition file and publish the tile layer.

   The tile layer is published to your portal's hosting server, and both the service definition and the tiles are added to My Content.

8. When the tile layer has been published, you will be given the option to Start building tiles. Click that link to create the tiles.

By default, only you have access to the service definition file and hosted tile layer. You can share the file and tiles with others in your organization or specific groups.

Run a script to upload and publish

To upload and publish a service definition file after hours, automate the following script to run on your GIS Server machine:

1. Copy the following script into a text file and save the file with a .py extension.

   import os, sys, json, urllib, urllib2, httplib, urlparse, mimetools, mimetypes
   from cStringIO import StringIO
   
   # generates a new token from Portal
   def generate_token(baseurl, username, password):
       tokenUrl = urlparse.urljoin(baseurl, 'sharing/generateToken')
       postdata = { 'username': username, 'password': password,
                  'client': 'requestip', 'expiration': 60, 'f': 'json' }
       encoded_postdata = urllib.urlencode(postdata)
       opener = urllib2.build_opener()
       try: resp = opener.open(tokenUrl, data=encoded_postdata)
       except urllib2.HTTPError as e: raise Exception('Unable to connect to Portal, please check the url: {} {}'.format(e.code, e.reason))
       resp_json = json.loads(resp.read())
       if 'error' in resp_json: raise Exception('\n'.join(resp_json['error']['details']))
       return resp_json['token']
       sys.exit(1)
   
   # create proper multi-part POST request data
   def _encode_multipart_formdata(fields, files):
       boundary = mimetools.choose_boundary()
       buf = StringIO()
       for (key, value) in fields.iteritems():
           buf.write('--%s\r\n' % boundary)
           buf.write('Content-Disposition: form-data; name="%s"' % key)
           buf.write('\r\n\r\n%s\r\n' % str(value))
       for (key, filepath, filename) in files:
           buf.write('--%s\r\n' % boundary)
           buf.write('Content-Disposition: form-data; name="%s"; filename="%s"\r\n' % (key, filename))
           buf.write('Content-Type: %s\r\n' % (mimetypes.guess_type(filename)[0] or 'application/octet-stream'))
           f = open(filepath, "rb")
           try:
               buf.write('\r\n' + f.read() + '\r\n')
           finally:
               f.close()
       buf.write('--' + boundary + '--\r\n\r\n')
       buf = buf.getvalue()
       return boundary, buf
   
   # send multi-part POST request
   def _postmultipart(host, selector, fields, files, ssl):
       boundary, body = _encode_multipart_formdata(fields, files)
       headers = { 'Content-Type': 'multipart/form-data; boundary={0}'.format(boundary) }
       if ssl: h = httplib.HTTPSConnection(host)
       else: h = httplib.HTTPConnection(host)
       
       h.request('POST', selector, body, headers)
       resp = h.getresponse()
   
       return resp.read()
   
   # first upload the SD file and create an item in Portal
   def addSDItem(baseurl, user, token, title, file, folder = ''):
       addUrl = 'sharing/rest/content/users/{}/{}addItem'
       if folder != '': addUrl = addUrl.format(user, folder + '/')
       else: addUrl = addUrl.format(user, '')
       
       url = urlparse.urljoin(baseurl, addUrl)
   
       files = [('file', file, os.path.split(file)[1])]
       fields = { 'token' : token, 'f' : 'json', 'type' : 'Service Definition', 'title' : title, 
                  'tags' : 'sampletag', 'name': title, 'typeKeywords' : 'Data, Service Definition, ArcGIS, sd' }
   
       ssl = url.startswith('https://')
       
       parsed_url = urlparse.urlparse(url)
       
       print('Uploading {} to {}..'.format(file, baseurl))
       resp = _postmultipart(parsed_url.netloc, str(parsed_url.path), fields, files, ssl)
       resp_json = json.loads(resp)
   
       if 'error' in resp_json:
         raise Exception('Unable to upload file {}: {}'.format(file, resp_json['error']['message']))
       
       return resp_json['id']
       
   # second publish the uploaded SD item as a new tiled service
   def publishTiles(baseurl, user, token, itemid):
       publishUrl = urlparse.urljoin(baseurl, 'sharing/rest/content/users/{}/publish'.format(user))
       query_dict= { 'f' : 'json', 'token': token, 'itemid': itemid, 'buildInitialCache' : True,
                     'publishParameters' : { 'name' : 'cities' }, 'fileType': 'serviceDefinition' }
                     
       query_string = urllib.urlencode(query_dict)
       print('Publishing tile service from item..')
       response = urllib.urlopen(publishUrl, query_string)
           
       resp_json = json.loads(response.read())
       
       if 'error' in resp_json: raise Exception('Unable to publish item: {}'.format(resp_json['error']['message']))
   
   # read input from command line when run as a standalone script
   if __name__ == '__main__':
       try: 
         url = sys.argv[1]
         user = sys.argv[2]
         password = sys.argv[3]
         f = sys.argv[4]
         title = sys.argv[5]
         if not url.endswith('/'): url += '/' # make sure the url ends with /
       except: # if too few parameters are passed on command line, show usage help
         print('Usage: ')
         print('       publishServiceItem.py [portalUrl] [userName] [password] [sdFilePath] [titleOfServiceItem]')
         print('')
         print('portalUrl           The secure url to the portal, e.g. https://portalmachine.example.com/arcgis/')
         print('userName            The username of a user to publish the service.')
         print('                    This user must have the required publishing privileges.')
         print('password            The password of the user')
         print('sdFilePath          Path to the .sd file containing the service definition')
         print('                    E.g. c:\\temp\cachedService.sd')
         print('titleOfServiceItem  The title to assign to the published item in the portal.')
         sys.exit(1)  
   
       token = generate_token(url, user, password)
   
       id = addSDItem(url, user, token, title, f)
       publishTiles(url, user, token, id)
       print('Publishing complete. Tile generation has been started and may take a while to finish.')

2. Create a batch file or shell script that you will schedule to run the Python script.
3. In the file, call the Python script and provide options specific to your site.

   For example, to run the script publishServiceItem.py, type the URL to your portal, the user name with which to connect, the user's password, the path to the service definition file, and a title for the service to be created. In this example, the portal URL is https://portal.domain.com/arcgis/, the user name and password are pub1 and pub.1, the path to the service definition file is C:\maps\SDs\mymap.sd, and the service name is studytiles.

   publishServiceItem.py https://portal.domain.com/arcgis/ pub1 pub.1 C:\maps\SDs\mymap.sd studytiles

   Tip:

   Alternatively, you can use the following simplified script to upload a service definition file to your portal, publish a tile layer, and build a cache. However, you must install additional Python packages—PortalPy and Python Requests—to run this script. PortalPy is installed with Portal for ArcGIS. See Scripting administrative tasks with PortalPy in the Portal for ArcGIS help for more information on installing and using this module.

   import portalpy, requests, urlparse, sys, os
   
   # first upload the SD file and create an item in Portal
   def addSDItem(baseurl, user, token, title, file, folder = ''):
       addUrl = 'sharing/rest/content/users/{}/{}addItem'
       if folder != '': addUrl = addUrl.format(user, folder + '/')
       else: addUrl = addUrl.format(user, '')
       
       url = urlparse.urljoin(baseurl, addUrl)
   
       files = { 'file' : (os.path.split(file)[1], open(file, 'rb')) }
       fields = { 'token' : token, 'f' : 'json', 'type' : 'Service Definition', 'title' : title, 
                  'tags' : 'sampletag', 'name': title, 'typeKeywords' : 'Data, Service Definition, ArcGIS, sd' }
   
       print('Uploading {} to {}..'.format(file, baseurl))
       
       # send POST with upload request
       # verify=False turns off SSL cert validation, turn on for production environments with CA-signed certs
       resp = requests.post(url, data=fields, files=files, verify=False)
       resp_json = resp.json()
   
       if 'error' in resp_json:
         raise Exception('Unable to upload file {}: {}'.format(file, resp_json['error']['message']))
       
       return resp_json['id']
   
   # second publish the uploaded SD item as a new tiled service
   def publishTiles(baseurl, user, token, itemid):
       publishUrl = urlparse.urljoin(baseurl, 'sharing/rest/content/users/{}/publish'.format(user))
       query_dict= { 'f' : 'json', 'token': token, 'itemid': itemid, 'buildInitialCache' : True,
                     'publishParameters' : "{ 'name' : 'cities' }", 'fileType': 'serviceDefinition' }
       
       print('Publishing tile service from item..')
       
       # send POST with publish request
       # verify=False turns off SSL cert validation, turn on for production environments with CA-signed certs
       response = requests.post(publishUrl, data=query_dict, verify=False) 
           
       resp_json = response.json()
       
       if 'error' in resp_json: raise Exception('Unable to publish item: {}'.format(resp_json['error']['message']))
   
   # read input from command line when run as a standalone script
   if __name__ == '__main__':
       try: 
         url = sys.argv[1]
         user = sys.argv[2]
         password = sys.argv[3]
         f = sys.argv[4]
         title = sys.argv[5]
         if not url.endswith('/'): url += '/' # make sure the url ends with /
       except: # if too few parameters are passed on command line, show usage help
         print('Usage: ')
         print('       publishServiceItem.py [portalUrl] [userName] [password] [sdFilePath] [titleOfServiceItem]')
         print('')
         print('portalUrl           The secure url to the portal, e.g. https://portalmachine.example.com/arcgis/')
         print('userName            The username of a user to publish the service.')
         print('                    This user must have the required publishing privileges.')
         print('password            The password of the user')
         print('sdFilePath          Path to the .sd file containing the service definition')
         print('                    E.g. c:\\temp\cachedService.sd')
         print('titleOfServiceItem  The title to assign to the published item in the portal.')
         sys.exit(1) 
   
       portal = portalpy.Portal(url, user, password)
       token = portal.generate_token(user, password)
   
       id = addSDItem(url, user, token, title, f)
       publishTiles(url, user, token, id)
       print('Publishing complete. Tile generation has been started and may take a while to finish.')

4. Schedule your script to run when your portal usage is lowest.

   See Scheduling a Python script to run at prescribed times in the ArcGIS geoprocessing help for more information on scheduling a script.